@Override
        @Nullable
        public Action<? super ExecutionListener> createAction(CommandLineParser parser, ParsedCommandLine commandLine) {
            if (commandLine.hasOption(HELP)) {
                return new ShowUsageAction(parser);
            }
            if (commandLine.hasOption(VERSION)) {
                return new ShowVersionAction();
            }
            return null;
        }
    }

            </thead>
            <tr>
                <td>args</td>
            </tr>
            <tr>
                <td>argumentProviders</td>
            </tr>
            <tr>
                <td>commandLine</td>
            </tr>
            <tr>
                <td>executable</td>
            </tr>
            <tr>
                <td>workingDir</td>
            </tr>
            <tr>

        def converter = new InitialPropertiesConverter()
        def parser = new CommandLineParser()
        converter.configure(parser)
        def commandLine = parser.parse("-Done=12", "-Dtwo")
        def result = converter.convert(commandLine)

        expect:
        result.requestedSystemProperties.size() == 2
        result.requestedSystemProperties.get("one") == "12"

        succeeds ':printSystemProp'

        then:
        outputContains('mySystemProp=properties file')

        when:
        args '-DmySystemProp=commandline'
        succeeds ':printSystemProp'

        then:
        outputContains('mySystemProp=commandline')
    }

    @Requires(IntegTestPreconditions.NotEmbeddedExecutor) // needs to run Gradle from command line
    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)

        buildOptions.commandLineConverter().configure(parser);
    }

    public void convert(ParsedCommandLine commandLine, Map<String, String> properties, T target) {
        buildOptions.propertiesConverter().convert(properties, target);
        buildOptions.commandLineConverter().convert(commandLine, target);
    }

        systemPropertiesCommandLineConverter.configure(parser);
    }

    public InitialProperties convert(ParsedCommandLine commandLine) {
        Map<String, String> requestedSystemProperties = systemPropertiesCommandLineConverter.convert(commandLine, new HashMap<>());

        return new InitialProperties() {
            @Override
            public Map<String, String> getRequestedSystemProperties() {

/**
 * Executes a command line process. Example:
 * <pre class='autoTested'>
 * task stopTomcat(type:Exec) {
 *   workingDir '../tomcat/bin'
 *
 *   //on windows:
 *   commandLine 'cmd.exe', '/d', '/c', 'stop.bat'
 *
 *   //on linux
 *   commandLine './stop.sh'
 *
 *   //store the output instead of printing to the console:
 *   standardOutput = new ByteArrayOutputStream()
 *

        return []
    }

    static List<SystemPropertyInjection> all(String prop, String value) {
        return [
            commandLine(prop, value),
            gradleProperties(prop, value),
            clientJvmArgs(prop, value)
        ]
    }

    static SystemPropertyInjection commandLine(String prop, String value) {
        return new SystemPropertyInjection() {
            @Override
            String getDescription() {

    def "spec sets commandLine on parameters"() {
        given:
        def parameters = newParameters()
        def command = ["some", "arguments"]

        when:
        (specUnderTest as JavaExecSpec).args(command)
        specUnderTest.copyToParameters(parameters)

        then:
        getSuffix(parameters.commandLine.get(), command.size()) == command
    }

    @Override

You can also connect using any S3-compatible tool, such as the MinIO Client `mc` commandline tool. See
[Test using MinIO Client `mc`](#test-using-minio-client-mc) for more information on using the `mc` commandline tool. For application developers,
see <https://min.io/docs/minio/linux/developers/minio-drivers.html> to view MinIO SDKs for supported languages.