getExecOperations().exec(spec -> spec.commandLine("git", "clone", "--no-checkout", remoteUri, destinationDir.getAbsolutePath()));
        }
        getExecOperations().exec(spec -> {
            spec.commandLine("git", "checkout", getCommitId().get());
            spec.setWorkingDir(destinationDir);
        });
        getExecOperations().exec(spec -> {
            spec.commandLine("git", "clean", "-fdx");

        getDelegate().setCommandLine(args);
    }

    @Override
    default ExecSpec commandLine(Object... args) {
        getDelegate().commandLine(args);
        return this;
    }

    @Override
    default ExecSpec commandLine(Iterable<?> args) {
        getDelegate().commandLine(args);
        return this;
    }

    @Override
    default ExecSpec args(Object... args) {

	"fmt"
	"io"
	"log"
	"os"

	"internal/trace"
	"internal/trace/testtrace"
)

func init() {
	flag.Usage = func() {
		fmt.Fprintf(flag.CommandLine.Output(), "Usage: %s\n", os.Args[0])
		fmt.Fprintf(flag.CommandLine.Output(), "\n")
		fmt.Fprintf(flag.CommandLine.Output(), "Accepts a trace at stdin and validates it.\n")
		flag.PrintDefaults()
	}
	log.SetFlags(0)
}

        CommandLineParser parser = new DefaultParser();
        CommandLine cmd = parser.parse(options, args);

        if (cmd.hasOption("debug")) {
            printModuleDebug(Main.class);
            printModuleDebug(Gson.class);
            printModuleDebug(StringUtils.class);
            printModuleDebug(CommandLine.class);
            printModuleDebug(BeanUtils.class);
        }

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

        when:
        specUnderTest.commandLine = command
        specUnderTest.copyToParameters(parameters)

        then:
        parameters.commandLine.get() == command
    }

    @Override

    }

    public BuildLayoutResult convert(InitialProperties systemProperties, ParsedCommandLine commandLine, @Nullable File workingDir) {
        return convert(systemProperties, commandLine, workingDir, parameters -> {
        });
    }

    public BuildLayoutResult convert(InitialProperties systemProperties, ParsedCommandLine commandLine, @Nullable File workingDir, Consumer<BuildLayoutParameters> defaults) {

func Parse() {
	// Ignore errors; CommandLine is set for ExitOnError.
	CommandLine.Parse(os.Args[1:])
}

// Parsed reports whether the command-line flags have been parsed.
func Parsed() bool {
	return CommandLine.Parsed()
}

// CommandLine is the default set of command-line flags, parsed from [os.Args].

        val execOutput = providers.exec {
            workingDir = projectDir
            isIgnoreExitValue = true
            commandLine = listOf("git", *args)
            if (OperatingSystem.current().isWindows) {
                commandLine = listOf("cmd.exe", "/d", "/c") + commandLine
            }
        }
        return execOutput.result.zip(execOutput.standardOutput.asText) { result, outputText ->

      client.connectionPool.evictAll()
      client.dispatcher.executorService.shutdownNow()

      if (launch == CommandLine) {
        process?.destroyForcibly()
      }
    }
  }

  private fun sendTestRequest(request: Request) {
    try {
      if (this.launch != CommandLine) {
        println(request.url)
      }

      client.newCall(request)
        .execute()
        .use {

 */

package org.gradle.internal.cc.impl

class ConfigurationCacheSkipCacheIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "skip reading cached state on #commandLine"() {

        def configurationCache = newConfigurationCacheFixture()

        given:
        buildFile << """
            abstract class MyTask extends DefaultTask {