implab/gradle-common Commit - r62:c7861b56e1d8

Upgrade Gradle to 9.4.1 and fix functional tests

cin -

r62:c7861b56e1d8 default

parent child

Context file:

r62:c7861b56e1d8

Collapse all files

common/build.gradle +1 -1

             plugins {
                 id "java-library"
                 id "ivy-publish"
             }
             description = "Shared Gradle build utilities used by Implab plugins"
             java {
                 withJavadocJar()
                 withSourcesJar()
                 toolchain {
                     languageVersion = JavaLanguageVersion.of(21)
                 }
             }
             dependencies {
                 compileOnly libs.jdt.annotations
                 api gradleApi(),
                     libs.bundles.jackson
                 testImplementation gradleTestKit()
                 testImplementation "org.junit.jupiter:junit-jupiter-api:5.11.4"
                 testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.11.4"
                 testRuntimeOnly "org.junit.platform:junit-platform-launcher:1.11.4"
             }
             task printVersion{
                 doLast {
                     println "project: $project.group:$project.name:$project.version"
                     println "jar: ${->jar.archiveFileName.get()}"
                 }
             }
             test {
                 useJUnitPlatform()
             }
             publishing {
                 repositories {
                     ivy {
-                        url "${System.properties["user.home"]}/ivy-repo"
+                        url = "${System.properties["user.home"]}/ivy-repo"
                     }
                 }
                 publications {
                     ivy(IvyPublication) {
                         from components.java
                         descriptor.description {
                             text = providers.provider({ description })
                         }
                         descriptor.license {
                             name = "BSD-2-Clause"
                             url = "https://spdx.org/licenses/BSD-2-Clause.html"
                         }
                     }
                 }
             }

gradle/wrapper/gradle-wrapper.jar binary modified 0 0

NO CONTENT: modified file, binary diff hidden

gradle/wrapper/gradle-wrapper.properties +1 -1

             distributionBase=GRADLE_USER_HOME
             distributionPath=wrapper/dists
-            distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
+            distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
             networkTimeout=10000
             validateDistributionUrl=true
             zipStoreBase=GRADLE_USER_HOME
             zipStorePath=wrapper/dists

gradlew +5 -2

             #!/bin/sh
             #
             # Copyright © 2015-2021 the original authors.
             #
             # Licensed under the Apache License, Version 2.0 (the "License");
             # you may not use this file except in compliance with the License.
             # You may obtain a copy of the License at
             #
             #      https://www.apache.org/licenses/LICENSE-2.0
             #
             # Unless required by applicable law or agreed to in writing, software
             # distributed under the License is distributed on an "AS IS" BASIS,
             # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
             # See the License for the specific language governing permissions and
             # limitations under the License.
             #
+            # SPDX-License-Identifier: Apache-2.0
+            #
             ##############################################################################
             #
             #   Gradle start up script for POSIX generated by Gradle.
             #
             #   Important for running:
             #
             #   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
             #       noncompliant, but you have some other compliant shell such as ksh or
             #       bash, then to run this script, type that shell name before the whole
             #       command line, like:
             #
             #           ksh Gradle
             #
             #       Busybox and similar reduced shells will NOT work, because this script
             #       requires all of these POSIX shell features:
             #         * functions;
             #         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
             #           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
             #         * compound commands having a testable exit status, especially «case»;
             #         * various built-in commands including «command», «set», and «ulimit».
             #
             #   Important for patching:
             #
             #   (2) This script targets any POSIX shell, so it avoids extensions provided
             #       by Bash, Ksh, etc; in particular arrays are avoided.
             #
             #       The "traditional" practice of packing multiple parameters into a
             #       space-separated string is a well documented source of bugs and security
             #       problems, so this is (mostly) avoided, by progressively accumulating
             #       options in "$@", and eventually passing that to Java.
             #
             #       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
             #       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
             #       see the in-line comments for details.
             #
             #       There are tweaks for specific operating systems such as AIX, CygWin,
             #       Darwin, MinGW, and NonStop.
             #
             #   (3) This script is generated from the Groovy template
-            #       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+            #       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
             #       within the Gradle project.
             #
             #       You can find Gradle at https://github.com/gradle/gradle/.
             #
             ##############################################################################
             # Attempt to set APP_HOME
             # Resolve links: $0 may be a link
             app_path=$0
             # Need this for daisy-chained symlinks.
             while
                 APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
                 [ -h "$app_path" ]
             do
                 ls=$( ls -ld "$app_path" )
                 link=${ls#*' -> '}
                 case $link in             #(
                   /*)   app_path=$link ;; #(
                   *)    app_path=$APP_HOME$link ;;
                 esac
             done
             # This is normally unused
             # shellcheck disable=SC2034
             APP_BASE_NAME=${0##*/}
             # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-            APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+            APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+            ' "$PWD" ) || exit
             # Use the maximum available, or set MAX_FD != -1 to use that value.
             MAX_FD=maximum
             warn () {
                 echo "$*"
             } >&2
             die () {
                 echo
                 echo "$*"
                 echo
                 exit 1
             } >&2
             # OS specific support (must be 'true' or 'false').
             cygwin=false
             msys=false
             darwin=false
             nonstop=false
             case "$( uname )" in                #(
               CYGWIN* )         cygwin=true  ;; #(
               Darwin* )         darwin=true  ;; #(
               MSYS* | MINGW* )  msys=true    ;; #(
               NONSTOP* )        nonstop=true ;;
             esac
             CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
             # Determine the Java command to use to start the JVM.
             if [ -n "$JAVA_HOME" ] ; then
                 if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
                     # IBM's JDK on AIX uses strange locations for the executables
                     JAVACMD=$JAVA_HOME/jre/sh/java
                 else
                     JAVACMD=$JAVA_HOME/bin/java
                 fi
                 if [ ! -x "$JAVACMD" ] ; then
                     die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
             Please set the JAVA_HOME variable in your environment to match the
             location of your Java installation."
                 fi
             else
                 JAVACMD=java
                 if ! command -v java >/dev/null 2>&1
                 then
                     die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
             Please set the JAVA_HOME variable in your environment to match the
             location of your Java installation."
                 fi
             fi
             # Increase the maximum file descriptors if we can.
             if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
                 case $MAX_FD in #(
                   max*)
                     # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
                     # shellcheck disable=SC2039,SC3045
                     MAX_FD=$( ulimit -H -n ) ||
                         warn "Could not query maximum file descriptor limit"
                 esac
                 case $MAX_FD in  #(
                   '' | soft) :;; #(
                   *)
                     # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
                     # shellcheck disable=SC2039,SC3045
                     ulimit -n "$MAX_FD" ||
                         warn "Could not set maximum file descriptor limit to $MAX_FD"
                 esac
             fi
             # Collect all arguments for the java command, stacking in reverse order:
             #   * args from the command line
             #   * the main class name
             #   * -classpath
             #   * -D...appname settings
             #   * --module-path (only if needed)
             #   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
             # For Cygwin or MSYS, switch paths to Windows format before running java
             if "$cygwin" || "$msys" ; then
                 APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
                 CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
                 JAVACMD=$( cygpath --unix "$JAVACMD" )
                 # Now convert the arguments - kludge to limit ourselves to /bin/sh
                 for arg do
                     if
                         case $arg in                                #(
                           -*)   false ;;                            # don't mess with options #(
                           /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
                                 [ -e "$t" ] ;;                      #(
                           *)    false ;;
                         esac
                     then
                         arg=$( cygpath --path --ignore --mixed "$arg" )
                     fi
                     # Roll the args list around exactly as many times as the number of
                     # args, so each arg winds up back in the position where it started, but
                     # possibly modified.
                     #
                     # NB: a `for` loop captures its iteration list before it begins, so
                     # changing the positional parameters here affects neither the number of
                     # iterations, nor the values presented in `arg`.
                     shift                   # remove old arg
                     set -- "$@" "$arg"      # push replacement arg
                 done
             fi
             # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
             DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
             # Collect all arguments for the java command:
             #   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
             #     and any embedded shellness will be escaped.
             #   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
             #     treated as '${Hostname}' itself on the command line.
             set -- \
                     "-Dorg.gradle.appname=$APP_BASE_NAME" \
                     -classpath "$CLASSPATH" \
                     org.gradle.wrapper.GradleWrapperMain \
                     "$@"
             # Stop when "xargs" is not available.
             if ! command -v xargs >/dev/null 2>&1
             then
                 die "xargs is not available"
             fi
             # Use "xargs" to parse quoted args.
             #
             # With -n1 it outputs one arg per line, with the quotes and backslashes removed.
             #
             # In Bash we could simply go:
             #
             #   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
             #   set -- "${ARGS[@]}" "$@"
             #
             # but POSIX shell has neither arrays nor command substitution, so instead we
             # post-process each arg (as a line of input to sed) to backslash-escape any
             # character that might be a shell metacharacter, then use eval to reverse
             # that process (while maintaining the separation between arguments), and wrap
             # the whole thing up as a single "set" statement.
             #
             # This will of course break if any of these variables contains a newline or
             # an unmatched quote.
             #
             eval "set -- $(
                     printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
                     xargs -n1 |
                     sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
                     tr '\n' ' '
                 )" '"$@"'
             exec "$JAVACMD" "$@"

gradlew.bat +2 0

             @rem
             @rem Copyright 2015 the original author or authors.
             @rem
             @rem Licensed under the Apache License, Version 2.0 (the "License");
             @rem you may not use this file except in compliance with the License.
             @rem You may obtain a copy of the License at
             @rem
             @rem      https://www.apache.org/licenses/LICENSE-2.0
             @rem
             @rem Unless required by applicable law or agreed to in writing, software
             @rem distributed under the License is distributed on an "AS IS" BASIS,
             @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
             @rem See the License for the specific language governing permissions and
             @rem limitations under the License.
             @rem
+            @rem SPDX-License-Identifier: Apache-2.0
+            @rem
             @if "%DEBUG%"=="" @echo off
             @rem ##########################################################################
             @rem
             @rem  Gradle startup script for Windows
             @rem
             @rem ##########################################################################
             @rem Set local scope for the variables with windows NT shell
             if "%OS%"=="Windows_NT" setlocal
             set DIRNAME=%~dp0
             if "%DIRNAME%"=="" set DIRNAME=.
             @rem This is normally unused
             set APP_BASE_NAME=%~n0
             set APP_HOME=%DIRNAME%
             @rem Resolve any "." and ".." in APP_HOME to make it shorter.
             for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
             @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
             set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
             @rem Find java.exe
             if defined JAVA_HOME goto findJavaFromJavaHome
             set JAVA_EXE=java.exe
             %JAVA_EXE% -version >NUL 2>&1
             if %ERRORLEVEL% equ 0 goto execute
             echo. 1>&2
             echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
             echo. 1>&2
             echo Please set the JAVA_HOME variable in your environment to match the 1>&2
             echo location of your Java installation. 1>&2
             goto fail
             :findJavaFromJavaHome
             set JAVA_HOME=%JAVA_HOME:"=%
             set JAVA_EXE=%JAVA_HOME%/bin/java.exe
             if exist "%JAVA_EXE%" goto execute
             echo. 1>&2
             echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
             echo. 1>&2
             echo Please set the JAVA_HOME variable in your environment to match the 1>&2
             echo location of your Java installation. 1>&2
             goto fail
             :execute
             @rem Setup the command line
             set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
             @rem Execute Gradle
             "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
             :end
             @rem End local scope for the variables with windows NT shell
             if %ERRORLEVEL% equ 0 goto mainEnd
             :fail
             rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
             rem the _cmd.exe /c_ return code!
             set EXIT_CODE=%ERRORLEVEL%
             if %EXIT_CODE% equ 0 set EXIT_CODE=1
             if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
             exit /b %EXIT_CODE%
             :mainEnd
             if "%OS%"=="Windows_NT" endlocal
             :omega

settings.gradle +1 -1

             /*
              * This settings file was generated by the Gradle 'init' task.
              *
              * The settings file is used to specify which projects to include in your build.
              * In a single project build this file can be empty or even removed.
              *
              * Detailed information about configuring a multi-project build in Gradle can be found
              * in the user guide at https://docs.gradle.org/3.5/userguide/multi_project_builds.html
              */
             dependencyResolutionManagement {
                 repositories {
                     mavenCentral()
                     mavenLocal()
                     ivy {
-                        url "${System.properties["user.home"]}/ivy-repo"
+                        url = "${System.properties["user.home"]}/ivy-repo"
                     }
                 }
             }
             rootProject.name = 'gradle-common'
             include 'common'
             include 'variants'

variants/build.gradle +1 -1

             plugins {
                 id "java-library"
                 id "ivy-publish"
             }
             description = "Variant, source-set, and outgoing artifact model plugins for Gradle builds"
             java {
                 withJavadocJar()
                 withSourcesJar()
                 toolchain {
                     languageVersion = JavaLanguageVersion.of(21)
                 }
             }
             dependencies {
                 compileOnly libs.jdt.annotations
                 api gradleApi(),
                     project(":common")
                 testImplementation gradleTestKit()
                 testImplementation "org.junit.jupiter:junit-jupiter-api:5.11.4"
                 testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:5.11.4"
                 testRuntimeOnly "org.junit.platform:junit-platform-launcher:1.11.4"
             }
             task printVersion{
                 doLast {
                     println "project: $project.group:$project.name:$project.version"
                     println "jar: ${->jar.archiveFileName.get()}"
                 }
             }
             test {
                 useJUnitPlatform()
             }
             javadoc {
                 exclude "**/internal/**"
             }
             publishing {
                 repositories {
                     ivy {
-                        url "${System.properties["user.home"]}/ivy-repo"
+                        url = "${System.properties["user.home"]}/ivy-repo"
                     }
                 }
                 publications {
                     ivy(IvyPublication) {
                         from components.java
                         descriptor.description {
                             text = providers.provider({ description })
                         }
                         descriptor.license {
                             name = "BSD-2-Clause"
                             url = "https://spdx.org/licenses/BSD-2-Clause.html"
                         }
                     }
                 }
             }

variants/src/test/java/org/implab/gradle/variants/AbstractFunctionalTest.java +25 0

             package org.implab.gradle.variants;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import java.io.File;
             import java.io.IOException;
             import java.nio.file.Files;
             import java.nio.file.Path;
             import java.util.LinkedHashSet;
             import java.util.List;
             import java.util.stream.Collectors;
+            import java.util.regex.Pattern;
             import org.gradle.testkit.runner.GradleRunner;
             import org.gradle.testkit.runner.UnexpectedBuildFailure;
             import org.implab.gradle.common.core.lang.Deferred;
             import org.implab.gradle.variants.sources.GenericSourceSet;
             import org.junit.jupiter.api.io.TempDir;
             abstract class AbstractFunctionalTest {
                 private static final String SETTINGS_FILE = "settings.gradle";
                 private static final String BUILD_FILE = "build.gradle";
+                private static final Pattern INCLUDE_DECLARATION = Pattern.compile("^include(?:\\s|\\().*");
+                private static final Pattern QUOTED_LITERAL = Pattern.compile("['\"]([^'\"]+)['\"]");
                 @TempDir
                 Path testProjectDir;
                 protected void writeSettings(String rootProjectName) throws IOException {
                     writeFile(SETTINGS_FILE, "rootProject.name = '" + rootProjectName + "'\n");
                 }
                 protected void writeBuildFile(String body) throws IOException {
                     writeFile(BUILD_FILE, buildscriptClasspathBlock() + "\n" + body);
                 }
                 protected GradleRunner runner(String... arguments) {
                     return GradleRunner.create()
                             .withProjectDir(testProjectDir.toFile())
                             .withArguments(arguments)
                             .forwardOutput();
                 }
                 protected void assertBuildFails(String expectedError, String... arguments) {
                     var ex = org.junit.jupiter.api.Assertions.assertThrows(
                             UnexpectedBuildFailure.class,
                             () -> runner(arguments).build());
                     var output = ex.getBuildResult().getOutput();
                     assertTrue(output.contains(expectedError), () -> "Expected [" + expectedError + "] in output:\n" + output);
                 }
                 private static String buildscriptClasspathBlock() {
                     var classpath = pluginClasspath().stream()
                             .map(file -> "'" + file.getAbsolutePath().replace("\\", "\\\\") + "'")
                             .collect(Collectors.joining(", "));
                     return """
                             buildscript {
                                 dependencies {
                                     classpath files(%s)
                                 }
                             }
                             """.formatted(classpath);
                 }
                 private static List<File> pluginClasspath() {
                     try {
                         var files = new LinkedHashSet<File>();
                         files.add(codeSource(VariantSourcesPlugin.class));
                         files.add(resourceRoot("META-INF/gradle-plugins/org.implab.gradle-variants.properties"));
                         files.add(codeSource(GenericSourceSet.class));
                         files.add(codeSource(Deferred.class));
                         return List.copyOf(files);
                     } catch (Exception e) {
                         throw new RuntimeException("Unable to build plugin classpath for test", e);
                     }
                 }
                 private static File codeSource(Class<?> type) throws Exception {
                     return Path.of(type.getProtectionDomain().getCodeSource().getLocation().toURI()).toFile();
                 }
                 private static File resourceRoot(String resourceName) throws Exception {
                     var url = VariantSourcesPlugin.class.getClassLoader().getResource(resourceName);
                     if (url == null)
                         throw new IllegalStateException("Classpath resource isn't found: " + resourceName);
                     var path = Path.of(url.toURI());
                     var segments = resourceName.split("/").length;
                     for (var i = 0; i < segments; i++)
                         path = path.getParent();
                     return path.toFile();
                 }
                 protected void writeFile(String relativePath, String content) throws IOException {
                     Path path = testProjectDir.resolve(relativePath);
                     Files.createDirectories(path.getParent());
                     Files.writeString(path, content);
+                    if (SETTINGS_FILE.equals(relativePath))
+                        ensureIncludedProjectDirectories(content);
+                }
+                private void ensureIncludedProjectDirectories(String settingsContent) throws IOException {
+                    for (var line : settingsContent.split("\\R")) {
+                        var trimmed = line.strip();
+                        if (!INCLUDE_DECLARATION.matcher(trimmed).matches())
+                            continue;
+                        var matcher = QUOTED_LITERAL.matcher(trimmed);
+                        while (matcher.find()) {
+                            var projectPath = matcher.group(1);
+                            if (projectPath.startsWith(":"))
+                                projectPath = projectPath.substring(1);
+                            if (projectPath.isBlank())
+                                continue;
+                            Files.createDirectories(testProjectDir.resolve(projectPath.replace(':', File.separatorChar)));
+                        }
+                    }
                 }
             }

variants/src/test/java/org/implab/gradle/variants/VariantArtifactsPluginFunctionalTest.java +5 -5

             package org.implab.gradle.variants;
             import static org.junit.jupiter.api.Assertions.assertTrue;
             import org.gradle.testkit.runner.BuildResult;
             import org.gradle.testkit.runner.TaskOutcome;
             import org.junit.jupiter.api.Test;
             class VariantArtifactsPluginFunctionalTest extends AbstractFunctionalTest {
                 @Test
                 void gradleReferenceLazyOutgoingConfigurationAllowsSecondaryArtifactSelection() throws Exception {
                     writeFile("settings.gradle", """
                             rootProject.name = 'gradle-reference-outgoing-resolution'
                             include 'producer', 'consumer'
                             """);
                     writeFile("producer/inputs/typesPackage", "types\n");
                     writeFile("producer/inputs/js", "js\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             project(':producer') {
                                 def browserElements = configurations.consumable('browserElements')
                                 println('reference: registered browserElements provider')
                                 browserElements.configure { configuration ->
                                     println('reference: configuring browserElements')
                                     configuration.attributes.attribute(variantAttr, 'browser')
                                     configuration.outgoing.attributes.attribute(slotAttr, 'typesPackage')
                                     configuration.outgoing.artifact(layout.projectDirectory.file('inputs/typesPackage'))
                                     configuration.outgoing.variants.create('js') { secondary ->
                                         println('reference: creating js outgoing variant')
                                         secondary.attributes.attribute(slotAttr, 'js')
                                         secondary.artifact(layout.projectDirectory.file('inputs/js'))
                                     }
                                 }
                             }
                             project(':consumer') {
                                 configurations {
                                     compileView {
                                         canBeResolved = true
                                         canBeConsumed = false
                                         canBeDeclared = true
                                         attributes {
                                             attribute(variantAttr, 'browser')
                                             attribute(slotAttr, 'typesPackage')
                                         }
                                     }
                                 }
                                 dependencies {
                                     compileView project(':producer')
                                 }
                                 tasks.register('probe') {
                                     doLast {
                                         println('reference: resolving primary files')
                                         def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
                                         println('reference: resolving secondary files')
                                         def jsFiles = configurations.compileView.incoming.artifactView {
                                             attributes {
                                                 attribute(slotAttr, 'js')
                                             }
                                         }.files.files.collect { it.name }.sort().join(',')
                                         println('compileFiles=' + compileFiles)
                                         println('jsFiles=' + jsFiles)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner(":consumer:probe").build();
                     var output = result.getOutput();
                     var registered = output.indexOf("reference: registered browserElements provider");
                     var resolvingPrimary = output.indexOf("reference: resolving primary files");
                     var configuring = output.indexOf("reference: configuring browserElements");
                     var creatingSecondary = output.indexOf("reference: creating js outgoing variant");
                     var resolvingSecondary = output.indexOf("reference: resolving secondary files");
                     assertTrue(registered >= 0);
                     assertTrue(resolvingPrimary >= 0);
                     assertTrue(configuring >= 0);
                     assertTrue(creatingSecondary >= 0);
                     assertTrue(resolvingSecondary >= 0);
                     assertTrue(registered < resolvingPrimary);
                     assertTrue(resolvingPrimary < configuring);
                     assertTrue(configuring < creatingSecondary);
                     assertTrue(creatingSecondary < resolvingSecondary);
                     assertTrue(output.contains("compileFiles=typesPackage"));
                     assertTrue(output.contains("jsFiles=js"));
                 }
                 @Test
-                void gradleReferenceRegisteredSecondaryArtifactVariantIsNotRealizedBeforeResolution() throws Exception {
+                void gradleReferenceRegisteredSecondaryArtifactVariantAllowsSecondaryArtifactSelection() throws Exception {
-                    // Gradle issue: https://github.com/gradle/gradle/issues/27441
-                    // Registered outgoing artifact variants are not realized before dependency resolution.
                     writeFile("settings.gradle", """
                             rootProject.name = 'gradle-reference-registered-secondary-variant'
                             include 'producer', 'consumer'
                             """);
                     writeFile("producer/inputs/typesPackage", "types\n");
                     writeFile("producer/inputs/js", "js\n");
                     writeFile("build.gradle", """
                             import org.gradle.api.attributes.Attribute
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             project(':producer') {
                                 def browserElements = configurations.consumable('browserElements')
                                 browserElements.configure { configuration ->
                                     configuration.attributes.attribute(variantAttr, 'browser')
                                     configuration.outgoing.attributes.attribute(slotAttr, 'typesPackage')
                                     configuration.outgoing.artifact(layout.projectDirectory.file('inputs/typesPackage'))
                                     configuration.outgoing.variants.register('js') { secondary ->
                                         secondary.attributes.attribute(slotAttr, 'js')
                                         secondary.artifact(layout.projectDirectory.file('inputs/js'))
                                     }
                                 }
                             }
                             project(':consumer') {
                                 configurations {
                                     compileView {
                                         canBeResolved = true
                                         canBeConsumed = false
                                         canBeDeclared = true
                                         attributes {
                                             attribute(variantAttr, 'browser')
                                             attribute(slotAttr, 'typesPackage')
                                         }
                                     }
                                 }
                                 dependencies {
                                     compileView project(':producer')
                                 }
                                 tasks.register('probe') {
                                     doLast {
                                         def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
                                         def jsFiles = configurations.compileView.incoming.artifactView {
                                             attributes {
                                                 attribute(slotAttr, 'js')
                                             }
                                         }.files.files.collect { it.name }.sort().join(',')
                                         println('compileFiles=' + compileFiles)
                                         println('jsFiles=' + jsFiles)
                                     }
                                 }
                             }
                             """);
-                    assertBuildFails("Cannot create variant 'js' after dependency configuration ':producer:browserElements' has been resolved",
+                    BuildResult result = runner(":consumer:probe").build();
-                            ":consumer:probe");
+                    assertTrue(result.getOutput().contains("compileFiles=typesPackage"));
+                    assertTrue(result.getOutput().contains("jsFiles=js"));
                 }
                 @Test
                 void materializesPrimaryAndSecondarySlotsAndInvokesOutgoingHooks() throws Exception {
                     writeSettings("variant-artifacts-slots");
                     writeFile("inputs/base.js", "console.log('base')\n");
                     writeFile("inputs/amd.js", "console.log('amd')\n");
                     writeFile("inputs/mainJs.txt", "mainJs marker\n");
                     writeFile("inputs/amdJs.txt", "amdJs marker\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             variants.layers.create('mainBase')
                             variants.layers.create('mainAmd')
                             variants.roles.create('main')
                             variants.roles.create('test')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('mainBase', 'mainAmd')
                                 }
                             }
                             variantSources {
                                 layer('mainBase') {
                                     sourceSet {
                                         declareOutputs('js')
                                         registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
                                     }
                                 }
                                 layer('mainAmd') {
                                     sourceSet {
                                         declareOutputs('js')
                                         registerOutput('js', layout.projectDirectory.file('inputs/amd.js'))
                                     }
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('mainJs') {
                                         fromRole('main') {
                                             output('js')
                                         }
                                         from(layout.projectDirectory.file('inputs/mainJs.txt'))
                                     }
                                     slot('amdJs') {
                                         fromLayer('mainAmd') {
                                             output('js')
                                         }
                                         from(layout.projectDirectory.file('inputs/amdJs.txt'))
                                     }
                                 }
                                 whenOutgoingConfiguration { publication ->
                                     publication.configuration {
                                         attributes.attribute(variantAttr, publication.variant.name)
                                     }
                                 }
                                 whenOutgoingSlot { publication ->
                                     def slotName = publication.artifactSlot.slot.name
                                     publication.artifactAttributes {
                                         attribute(slotAttr, slotName)
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_mainJs'
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s5_amdJs'
                                 doLast {
                                     def mainDir = layout.buildDirectory.dir('variant-assemblies/browser/mainJs').get().asFile
                                     def amdDir = layout.buildDirectory.dir('variant-assemblies/browser/amdJs').get().asFile
                                     assert new File(mainDir, 'base.js').exists()
                                     assert new File(mainDir, 'amd.js').exists()
                                     assert new File(mainDir, 'mainJs.txt').exists()
                                     assert !new File(amdDir, 'base.js').exists()
                                     assert new File(amdDir, 'amd.js').exists()
                                     assert new File(amdDir, 'amdJs.txt').exists()
                                     def elements = configurations.getByName('browserElements')
                                     def amdVariant = elements.outgoing.variants.getByName('amdJs')
                                     println('variantAttr=' + elements.attributes.getAttribute(variantAttr))
                                     println('primarySlotAttr=' + elements.outgoing.attributes.getAttribute(slotAttr))
                                     println('amdSlotAttr=' + amdVariant.attributes.getAttribute(slotAttr))
                                     println('configurations=' + configurations.matching { it.name == 'browserElements' }.collect { it.name }.join(','))
                                     println('secondaryVariants=' + elements.outgoing.variants.collect { it.name }.sort().join(','))
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("variantAttr=browser"));
                     assertTrue(result.getOutput().contains("primarySlotAttr=mainJs"));
                     assertTrue(result.getOutput().contains("amdSlotAttr=amdJs"));
                     assertTrue(result.getOutput().contains("configurations=browserElements"));
                     assertTrue(result.getOutput().contains("secondaryVariants=amdJs"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void outgoingSlotHookFollowsMaterializedGradleArtifactVariants() throws Exception {
                     writeSettings("variant-artifacts-materialized-gradle-variant");
                     writeFile("inputs/typesPackage", "types\n");
                     writeFile("inputs/js", "js\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             def slotAttr = Attribute.of('test.slot', String)
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('typesPackage') {
                                         from(layout.projectDirectory.file('inputs/typesPackage'))
                                     }
                                 }
                                 whenOutgoingConfiguration { publication ->
                                     publication.configuration {
                                         outgoing.variants.create('js') { secondary ->
                                             secondary.artifact(layout.projectDirectory.file('inputs/js'))
                                         }
                                     }
                                 }
                                 whenOutgoingSlot { publication ->
                                     publication.artifactAttributes {
                                         attribute(slotAttr, publication.artifactSlot.slot.name)
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     def elements = configurations.getByName('browserElements')
                                     def jsVariant = elements.outgoing.variants.getByName('js')
                                     println('primarySlotAttr=' + elements.outgoing.attributes.getAttribute(slotAttr))
                                     println('jsSlotAttr=' + jsVariant.attributes.getAttribute(slotAttr))
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primarySlotAttr=typesPackage"));
                     assertTrue(result.getOutput().contains("jsSlotAttr=js"));
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void allowsSingleSlotVariantWithoutExplicitPrimarySlot() throws Exception {
                     writeSettings("variant-artifacts-single-slot");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
                                 sourceSet {
                                     declareOutputs('types')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('typesPackage') {
                                         fromVariant {
                                             output('types')
                                         }
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     variantArtifacts.whenAvailable { ctx ->
                                         def browser = objects.named(org.implab.gradle.variants.core.Variant, 'browser')
                                         println('primary=' + ctx.findOutgoing(browser).get().primarySlot.get().name)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.getOutput().contains("primary=typesPackage"));
                 }
                 @Test
                 void materializesDirectSlotInputsWithoutVariantSourceBindings() throws Exception {
                     writeSettings("variant-artifacts-direct-input");
                     writeFile("inputs/bundle.js", "console.log('bundle')\n");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('bundle') {
                                         from(layout.projectDirectory.file('inputs/bundle.js'))
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_bundle'
                                 doLast {
                                     def bundleDir = layout.buildDirectory.dir('variant-assemblies/browser/bundle').get().asFile
                                     assert new File(bundleDir, 'bundle.js').exists()
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void publishesTaskProducedFileArtifactDirectly() throws Exception {
                     writeFile("settings.gradle", """
                             rootProject.name = 'variant-artifacts-task-produced-file'
                             include 'producer', 'consumer'
                             """);
                     writeBuildFile("""
                             import org.gradle.api.DefaultTask
                             import org.gradle.api.attributes.Attribute
                             import org.gradle.api.file.RegularFileProperty
                             import org.gradle.api.tasks.OutputFile
                             import org.gradle.api.tasks.TaskAction
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             abstract class WritePackageMetadata extends DefaultTask {
                                 @OutputFile
                                 abstract RegularFileProperty getOutputFile()
                                 @TaskAction
                                 void write() {
                                     def file = outputFile.get().asFile
                                     file.parentFile.mkdirs()
                                     file.text = '{"name":"demo"}\\n'
                                 }
                             }
                             project(':producer') {
                                 apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                                 variants.layers.create('main')
                                 variants.roles.create('main')
                                 variants.variant('browser') {
                                     role('main') {
                                         layers('main')
                                     }
                                 }
                                 def writePackageMetadata = tasks.register('writePackageMetadata', WritePackageMetadata) {
                                     outputFile.set(layout.buildDirectory.file('generated/package.json'))
                                 }
                                 variantArtifacts {
                                     variant('browser') {
                                         primarySlot('packageMetadata') {
                                             producedBy(writePackageMetadata) {
                                                 outputFile
                                             }
                                         }
                                     }
                                     whenOutgoingConfiguration { publication ->
                                         publication.configuration {
                                             attributes.attribute(variantAttr, publication.variant.name)
                                         }
                                     }
                                     whenOutgoingSlot { publication ->
                                         publication.artifactAttributes {
                                             attribute(slotAttr, publication.artifactSlot.slot.name)
                                         }
                                     }
                                 }
                                 tasks.register('checkNoManagedAssembly') {
                                     doLast {
                                         def assemblyTasks = tasks.names
                                             .findAll { it.startsWith('assembleVariantArtifactSlot') }
                                             .sort()
                                         println('producerAssemblyTasks=' + assemblyTasks.join(','))
                                         assert assemblyTasks.empty
                                     }
                                 }
                             }
                             project(':consumer') {
                                 configurations {
                                     compileView {
                                         canBeResolved = true
                                         canBeConsumed = false
                                         canBeDeclared = true
                                         attributes {
                                             attribute(variantAttr, 'browser')
                                             attribute(slotAttr, 'packageMetadata')
                                         }
                                     }
                                 }
                                 dependencies {
                                     compileView project(':producer')
                                 }
                                 tasks.register('probe') {
                                     dependsOn configurations.compileView
                                     dependsOn ':producer:checkNoManagedAssembly'
                                     doLast {
                                         def files = configurations.compileView.files
                                         println('resolvedFiles=' + files.collect { it.name }.sort().join(','))
                                         println('metadata=' + files.iterator().next().text.trim())
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner(":consumer:probe").build();
                     assertTrue(result.getOutput().contains("producerAssemblyTasks="));
                     assertTrue(result.getOutput().contains("resolvedFiles=package.json"));
                     assertTrue(result.getOutput().contains("metadata={\"name\":\"demo\"}"));
                     assertTrue(result.task(":producer:writePackageMetadata").getOutcome() == TaskOutcome.SUCCESS);
                     assertTrue(result.task(":consumer:probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void failsWhenTaskProducedArtifactIsMixedWithContributionAssembly() throws Exception {
                     writeSettings("variant-artifacts-mixed-assembly-mode");
                     writeFile("inputs/marker.txt", "marker\n");
                     writeBuildFile("""
                             import org.gradle.api.DefaultTask
                             import org.gradle.api.file.RegularFileProperty
                             import org.gradle.api.tasks.OutputFile
                             import org.gradle.api.tasks.TaskAction
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             abstract class WritePackageMetadata extends DefaultTask {
                                 @OutputFile
                                 abstract RegularFileProperty getOutputFile()
                                 @TaskAction
                                 void write() {
                                     outputFile.get().asFile.text = '{}\\n'
                                 }
                             }
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             def writePackageMetadata = tasks.register('writePackageMetadata', WritePackageMetadata) {
                                 outputFile.set(layout.buildDirectory.file('generated/package.json'))
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('packageMetadata') {
                                         producedBy(writePackageMetadata) {
                                             outputFile
                                         }
                                         from(layout.projectDirectory.file('inputs/marker.txt'))
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("cannot mix task-produced artifact and contribution-based assembly", "help");
                 }
                 @Test
                 void combinesDirectAndTopologyAwareSlotInputs() throws Exception {
                     writeSettings("variant-artifacts-combined-inputs");
                     writeFile("inputs/base.js", "console.log('base')\n");
                     writeFile("inputs/marker.txt", "marker\n");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
                                 sourceSet {
                                     declareOutputs('js')
                                     registerOutput('js', layout.projectDirectory.file('inputs/base.js'))
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     primarySlot('bundle') {
                                         fromVariant {
                                             output('js')
                                         }
                                         from(layout.projectDirectory.file('inputs/marker.txt'))
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 dependsOn 'assembleVariantArtifactSlot_v7_browser_s6_bundle'
                                 doLast {
                                     def bundleDir = layout.buildDirectory.dir('variant-assemblies/browser/bundle').get().asFile
                                     assert new File(bundleDir, 'base.js').exists()
                                     assert new File(bundleDir, 'marker.txt').exists()
                                 }
                             }
                             """);
                     BuildResult result = runner("probe").build();
                     assertTrue(result.task(":probe").getOutcome() == TaskOutcome.SUCCESS);
                 }
                 @Test
                 void failsOnUnknownVariantReference() throws Exception {
                     writeSettings("variant-artifacts-missing-variant");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variantArtifacts {
                                 variant('browser') {
                                     slot('mainJs') {
                                         fromVariant {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("isn't declared", "help");
                 }
                 @Test
                 void failsOnUnknownRoleReference() throws Exception {
                     writeSettings("variant-artifacts-missing-role");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('mainJs') {
                                         fromRole('test') {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Role projection for variant 'browser' and role 'test' not found", "help");
                 }
                 @Test
                 void failsWhenPrimarySlotIsMissingForMultipleSlots() throws Exception {
                     writeSettings("variant-artifacts-missing-primary");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('main')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('main')
                                 }
                             }
                             variantSources.layer('main') {
                                 sourceSet {
                                     declareOutputs('types', 'js')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('typesPackage') {
                                         fromVariant {
                                             output('types')
                                         }
                                     }
                                     slot('js') {
                                         fromVariant {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             tasks.register('probe') {
                                 doLast {
                                     variantArtifacts.whenAvailable { ctx ->
                                         def browser = objects.named(org.implab.gradle.variants.core.Variant, 'browser')
                                         ctx.findOutgoing(browser).get().primarySlot.get()
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Multiple slots declared for browser, please specify primary slot explicitly", "probe");
                 }
                 @Test
                 void failsOnLayerReferenceOutsideVariantTopology() throws Exception {
                     writeSettings("variant-artifacts-layer-outside-topology");
                     writeBuildFile("""
                             apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             variants.layers.create('mainBase')
                             variants.layers.create('extra')
                             variants.roles.create('main')
                             variants.variant('browser') {
                                 role('main') {
                                     layers('mainBase')
                                 }
                             }
                             variantArtifacts {
                                 variant('browser') {
                                     slot('extraJs') {
                                         fromLayer('extra') {
                                             output('js')
                                         }
                                     }
                                 }
                             }
                             """);
                     assertBuildFails("Compile unit for variant 'browser' and layer 'extra' not found", "help");
                 }
                 @Test
                 void preservesPrimaryResolutionAndAllowsSecondaryArtifactSelection() throws Exception {
                     writeFile("settings.gradle", """
                             rootProject.name = 'variant-artifacts-resolution'
                             include 'producer', 'consumer'
                             """);
                     writeFile("producer/inputs/types.d.ts", "export type Foo = string\n");
                     writeFile("producer/inputs/index.js", "export const foo = 'bar'\n");
                     writeBuildFile("""
                             import org.gradle.api.attributes.Attribute
                             def variantAttr = Attribute.of('test.variant', String)
                             def slotAttr = Attribute.of('test.slot', String)
                             subprojects {
                                 apply plugin: org.implab.gradle.variants.VariantArtifactsPlugin
                             }
                             project(':producer') {
                                 variants.layers.create('main')
                                 variants.roles.create('main')
                                 variants.variant('browser') {
                                     role('main') {
                                         layers('main')
                                     }
                                 }
                                 variantSources.layer('main') {
                                     sourceSet {
                                         declareOutputs('types', 'js')
                                         registerOutput('types', layout.projectDirectory.file('inputs/types.d.ts'))
                                         registerOutput('js', layout.projectDirectory.file('inputs/index.js'))
                                     }
                                 }
                                 variantArtifacts {
                                     variant('browser') {
                                         primarySlot('typesPackage') {
                                             fromVariant {
                                                 output('types')
                                             }
                                         }
                                         slot('js') {
                                             fromVariant {
                                                 output('js')
                                             }
                                         }
                                     }
                                     whenOutgoingConfiguration { publication ->
                                         publication.configuration {
                                             attributes.attribute(variantAttr, publication.variant.name)
                                         }
                                     }
                                     whenOutgoingSlot { publication ->
                                         publication.artifactAttributes {
                                             attribute(slotAttr, publication.artifactSlot.slot.name)
                                         }
                                     }
                                 }
                             }
                             project(':consumer') {
                                 configurations {
                                     compileView {
                                         canBeResolved = true
                                         canBeConsumed = false
                                         canBeDeclared = true
                                         attributes {
                                             attribute(variantAttr, 'browser')
                                             attribute(slotAttr, 'typesPackage')
                                         }
                                     }
                                 }
                                 dependencies {
                                     compileView project(':producer')
                                 }
                                 tasks.register('probe') {
                                     doLast {
                                         def compileFiles = configurations.compileView.files.collect { it.name }.sort().join(',')
                                         def jsFiles = configurations.compileView.incoming.artifactView {
                                             attributes {
                                                 attribute(slotAttr, 'js')
                                             }
                                         }.files.files.collect { it.name }.sort().join(',')
                                         println('compileFiles=' + compileFiles)
                                         println('jsFiles=' + jsFiles)
                                     }
                                 }
                             }
                             """);
                     BuildResult result = runner(":consumer:probe").build();
                     assertTrue(result.getOutput().contains("compileFiles=typesPackage"));
                     assertTrue(result.getOutput().contains("jsFiles=js"));
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages