}
        executer.withArguments('--max-workers', '4')
        succeeds("resolve")

        where:
        expression                                                       | _
        "configurations.compile"                                         | _

        return delegate.getArguments()
    }

    @Override
    SmokeTestGradleRunner withArguments(List<String> arguments) {
        delegate.withArguments(arguments)
        return this
    }

    @Override
    SmokeTestGradleRunner withArguments(String... arguments) {
        delegate.withArguments(arguments)
        return this
    }

    @Override

        then:
        file('libs').assertHasDescendants('projectB-1.0.jar')
        def snapshot = file('libs/projectB-1.0.jar').snapshot()

        when:
        server.resetExpectations()
        //expect no http requests

        and:
        version current withGradleUserHomeDir userHome withTasks 'retrieve' withArguments '-i' run()

        then:

            if (option != null) {
                // important to set arguments, and not JVM arguments, as it's what is used by Android Studio to set the option
                it.withArguments("-Dorg.gradle.internal.GradleProjectBuilderOptions=$option")
            }
        }

        then:
        result.assertOutputContains("realizing non-lazy task")
        if (realizesLazy) {

    /**
     * {@inheritDoc}
     * @since 1.0
     */
    @Override
    T withArguments(String... arguments);

    /**
     * {@inheritDoc}
     * @since 2.6
     */
    @Override
    T withArguments(Iterable<String> arguments);

    /**
     * {@inheritDoc}
     * @since 5.0
     */
    @Override
    T addArguments(String... arguments);

            buildFile << """
                apply plugin: 'java'
            """
        }

        when:
        withConnection {
            def executer = action(new FetchIdeaProject())
            executer.withArguments("--warning-mode", "all")
            collectOutputs(executer)
            executer.run()
        }

        then:
        !stdout.toString().contains("was resolved without accessing the project in a safe manner")

        artifactOps.size() == 1
        artifactOps[0].details.artifactIdentifier == 'impl-1.3.jar (org.utils:impl:1.3)'

        when:
        executer.withArguments("--refresh-dependencies")
        run "help"

        then:
        def metaDataOps2 = buildOperations.all(ExternalResourceReadMetadataBuildOperationType)
        metaDataOps2.size() == 2

    }

    void runPrevious() {
        previousExecuter.withArguments(argFor(previous.version), 'help').run()
    }

    void runCurrent() {
        currentExecuter.withArguments(argFor(current.version), 'help').run()
    }

    private static String argFor(GradleVersion version) {
        version.baseVersion < GradleVersion.version("6.6")

                        assert !logger.${nextLevel}Enabled
                    }
                }
            }
        """
        expect:
        executer.withArguments(flags)
        succeeds("assertLogging")
        outputContains(message)

        where:
        logLevel    | nextLevel   | flags
        'quiet'     | 'warn'      | ['-Dorg.gradle.logging.level=quiet']

     *          When the target Gradle version does not support some requested configuration option such as {@link #withArguments(String...)}.
     * @throws org.gradle.tooling.exceptions.UnsupportedBuildArgumentException When there is a problem with build arguments provided by {@link #withArguments(String...)}.
     * @throws BuildException On some failure executing the Gradle build.