def login = tasks.register('login', Exec) {
    def loginProvider = providers.credentials(PasswordCredentials, 'login')
    inputs.property('credentials', loginProvider)

    commandLine = ['sh', 'login.sh']
    doFirst {
        def loginCredentials = loginProvider.get()
        standardInput = new ByteArrayInputStream("$loginCredentials.username\n$loginCredentials.password".getBytes())
    }
}

tasks.register('doAuthenticated') {
    dependsOn(login)

        return execute(["bash"] as Object[], new ByteArrayInputStream(commands.getBytes()))
    }

    private String execute(Object[] commandLine, InputStream input) {
        def output = new ByteArrayOutputStream()
        def e = TestFiles.execHandleFactory().newExec()
                .commandLine(commandLine)
                .redirectErrorStream()
                .setStandardInput(input)
                .setStandardOutput(output)

     * @return this
     */
    ExecSpec commandLine(Object... args);

    /**
     * Sets the full command line, including the executable to be executed plus its arguments.
     *
     * @param args the command plus the args to be executed
     * @return this
     */
    ExecSpec commandLine(Iterable<?> args);

    /**
     * Adds arguments for the command to be executed.
     *

val login = tasks.register<Exec>("login") {
    val loginProvider = providers.credentials(PasswordCredentials::class.java, "login")
    inputs.property("credentials", loginProvider)

    commandLine = listOf("sh", "login.sh")
    doFirst {
        val loginCredentials = loginProvider.get()
        standardInput = java.io.ByteArrayInputStream("${loginCredentials.username}\n${loginCredentials.password}".toByteArray())
    }
}

        cleanTemporaryDir(fsOps, checkoutDir)
        execOps.exec {
            commandLine = ["git", "clone", "--no-checkout", remoteUri, checkoutDir.absolutePath]
            errorOutput = System.out
        }
        execOps.exec {
            commandLine = ["git", "checkout", ref]
            workingDir = checkoutDir
            errorOutput = System.out
        }

    def "Project.exec output is grouped with its task output"() {
        given:
        buildFile << """
            task run {
                doLast {
                    project.exec {
                        commandLine ${echo(EXPECTED_OUTPUT)}
                    }
                }
            }
        """

        when:
        executer.withConsole(consoleType)
        succeeds("run")

        then:

    @Inject
    abstract ExecOperations getExecOperations()

    String obtain() {
        ByteArrayOutputStream output = new ByteArrayOutputStream()
        execOperations.exec {
            it.commandLine "git", "--version"
            it.standardOutput = output
        }
        return new String(output.toByteArray(), Charset.defaultCharset())
    }
}
// end::value-source[]

// tag::create-provider[]

    @get:Inject
    abstract val execOperations: ExecOperations

    override fun obtain(): String {
        val output = ByteArrayOutputStream()
        execOperations.exec {
            commandLine("git", "--version")
            standardOutput = output
        }
        return String(output.toByteArray(), Charset.defaultCharset())
    }
}
// end::value-source[]

// tag::create-provider[]

To start a stopped container, you can use the [`docker start`](https://docs.docker.com/engine/reference/commandline/start/) command.

```sh
docker start <container_id>
```

To stop a running container, you can use the [`docker stop`](https://docs.docker.com/engine/reference/commandline/stop/) command.

```sh
docker stop <container_id>
```

### MinIO container logs

// required by the TensorFlow Graph(Def) to TF Lite Flatbuffer conversion. It is
// only intended to be included by binaries.

#include <string>

#include "llvm/Support/CommandLine.h"

// The commandline options are defined in LLVM style, so the caller should
// use llvm::InitLLVM to initialize the options.
//
// Please see the implementation file for documentation of details of these
// options.