class CommandLineIntegrationSpec extends AbstractIntegrationSpec {

    @Requires(IntegTestPreconditions.NotParallelExecutor)
    def "reasonable failure message when --max-workers=#value"() {
        given:
        executer.requireDaemon().requireIsolatedDaemons()  // otherwise exception gets thrown in testing infrastructure

        when:
        executer.withArgument("--max-workers=$value")

        then:
        fails "help"

        and:

        }
    }

    def "when requireDaemon is called, arguments should contain --daemon"() {
        when:
        executer.requireDaemon()
        def allArgs = executer.getAllArgs()

        then:
        allArgs.contains("--daemon")
        !allArgs.contains("--no-daemon")
    }

    def "when requireDaemon is not called, arguments should contain --no-daemon"() {
        when:

        super(distribution, testDirectoryProvider);
        super.requireDaemon();
    }

    public DaemonGradleExecuter(GradleDistribution distribution, TestDirectoryProvider testDirectoryProvider, GradleVersion gradleVersion, IntegrationTestBuildContext buildContext) {
        super(distribution, testDirectoryProvider, gradleVersion, buildContext);
        super.requireDaemon();
    }

    @Override

        version previous withTasks 'tasks' requireDaemon() requireIsolatedDaemons() run()
    }

    def "task can use all methods declared by Task interface that AbstractTask specialises"() {
        given:
        prepareMethodUseTest(current.version)

        expect:
        version current withTasks 'assemble' inDirectory(file("producer")) run()
        version previous requireDaemon() requireIsolatedDaemons() withTasks 't' run()
    }

        version current withTasks 'tasks' requireDaemon() requireIsolatedDaemons() run()
    }

    def "task can use all methods declared by Task interface that AbstractTask specialises"() {
        given:
        prepareMethodUseTest(previous.version)

        expect:
        version previous withTasks 'assemble' inDirectory(file("producer")) run()
        version current requireDaemon() requireIsolatedDaemons() withTasks 't' run()
    }

            javadoc {
                options {
                    windowTitle = "💩 💩 💩 💩"
                }
            }
        """
        executer.requireIsolatedDaemons()
        executer.requireDaemon()

        file("src/main/java/Main.java") << """
            public class Main {}
        """

        when:
        // Doesn't support the characters used in the title

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

        where:
        logLevel    | nextLevel   | flags

        if (executerType == Executer.embedded && !Charset.forName(defaultCharacterEncoding).equals(Charset.defaultCharset())) {
            // need to fork to apply the new default character encoding
            requireDaemon().requireIsolatedDaemons();
        }
        return super.withDefaultCharacterEncoding(defaultCharacterEncoding);
    }

    @Override
    public GradleExecuter withDefaultLocale(Locale defaultLocale) {

    def "caches native binaries in specified user home"() {
        given:
        executer.withNoExplicitNativeServicesDir()
        executer.requireOwnGradleUserHomeDir()
        executer.requireDaemon().requireIsolatedDaemons()

        when:
        succeeds "help"

        then:
        executer.gradleUserHomeDir.file("native").assertIsDir()
    }

                testLogging {
                    events "passed", "skipped", "failed"
                }
            }
        """.stripIndent()

        when:
        executer
            .requireDaemon()
            .requireIsolatedDaemons()
            .withBuildJvmOpts("-Duser.language=tr", "-Duser.country=TR")
            .withTasks("help")
            .run()

        then:
        noExceptionThrown()