import static org.gradle.api.internal.artifacts.result.ResolutionResultDataBuilder.newVariant

class DefaultResolutionResultTest extends Specification {

    def "provides all modules and dependencies including unresolved"() {
        given:
        def dep1 = newDependency('dep1')
        def dep2 = newDependency('dep2')

        def root = newModule('root').addDependency(dep1).addDependency(dep2)

        buildFile << """
            tasks.register("foo")
        """

        when:
        configurationCacheRun(":foo")
        then:
        def realizeOps = buildOperations.all(RealizeTaskBuildOperationType)
        realizeOps.size() == 2
        realizeOps*.details.each {
            assert it.taskPath == ":foo"
        }
        realizeOps.first().details.eager == false

        List<String> jvmOptions
        if (!originalJvmOptions) {
            jvmOptions = []
        } else {
            jvmOptions = originalJvmOptions.collect { it.toString() }  // makes sure that all elements are java.lang.String instances
        }
        if (!JavaVersion.current().isJava8Compatible() && jvmOptions.count { it.startsWith('-XX:MaxPermSize=') } == 0) {
            jvmOptions << '-XX:MaxPermSize=256m'
        }

            it.assertHasFirstCause("Could not resolve all files for configuration ':implementation'.")
        }
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.launcher.daemon.protocol;

/**
 * The supertype of all objects sent from the daemon server back to the client.
 * <p>
 * Specific subclass types carry extra context, e.g. whether it was a failure or successful result.
 * <p>

    pluginsRuntimeOnly(project(":configuration-cache")) {
        because("We always need a BuildLogicTransformStrategy service implementation.")
    }
    pluginsRuntimeOnly(project(":testing-junit-platform")) {
        because("All test workers have JUnit platform on their classpath (see ForkingTestClassProcessor.getTestWorkerImplementationClasspath).")
    }
    pluginsRuntimeOnly(project(":kotlin-dsl-provider-plugins")) {

            //
            // Add constructor
            //
            publicMethod(CONSTRUCTOR_NAME, RETURN_VOID_FROM_STRING, methodVisitor -> new MethodVisitorScope(methodVisitor) {{
                // Call this.super()
                _ALOAD(0);
                _INVOKESPECIAL(superClass, CONSTRUCTOR_NAME, RETURN_VOID);
                // Set this.name = param1
                _ALOAD(0);
                _ALOAD(1);

import javax.annotation.Nullable;
import javax.inject.Inject;

/**
 * Universal APIs that are available for all {@code dependencies} blocks.
 *
 * @apiNote This interface is intended to be used to mix-in DSL methods for {@code dependencies} blocks.
 * @implSpec The default implementation of all methods should not be overridden.
 * @implNote Changes to this interface may require changes to the

        given:
        // Why the separate plugin? The Project.getProperties() is available in the build.gradle as getProperties().
        // Therefore, it is impossible to call System.getProperties() with static import there, and testing static
        // import is important because Groovy generates different code in this case.
        file("buildSrc/src/main/groovy/SomePlugin.groovy") << """

     * </p>
     *
     * <p>
     * This method is exposed to the command line interface. Example usage:
     * <pre>gradle dependencyInsight --all-variants</pre>
     *
     * @since 7.5
     */
    @Option(option = "all-variants", description = "Show all variants of each dependency")
    @Incubating
    @Internal
    public Property<Boolean> getShowingAllVariants() {
        return showingAllVariants;
    }