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 {

// method calls in function bodies.

package flag

var commandLine = NewFlagSet() // ERROR "initialization cycle|depends upon itself"

type FlagSet struct {
}

func (f *FlagSet) failf(format string, a ...interface{}) {
	f.usage()
}

func (f *FlagSet) usage() {
	if f == commandLine {
		panic(3)
	}
}

func NewFlagSet() *FlagSet {
	f := &FlagSet{}

        @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);
    }