}

    /**
     * Additional parameters passed to the compiler.
     * Each parameter must start with '-'.
     *
     * @return The list of additional parameters.
     */
    @Optional
    @Input
    public List<String> getAdditionalParameters() {
        return additionalParameters;
    }

    /**
     * Sets the additional parameters.
     * <p>

        producer.visitProducerTasks { assert false }
        producer.visitContentProducerTasks { assert false }
    }

    void assertHasProducer(ProviderInternal<?> provider, Task task, Task... additional) {
        def expected = [task] + (additional as List)

        def producer = provider.producer
        assert producer.known
        def tasks = []
        producer.visitProducerTasks { tasks.add(it) }
        assert tasks == expected

    headersToDownstreamOnDeny: ["x-ext-authz-*"]
    includeRequestHeadersInCheck: ["x-ext-authz"]
    includeAdditionalHeadersInCheck:
      x-ext-authz-additional-header-new: additional-header-new-value
      x-ext-authz-additional-header-override: additional-header-override-value
- name: "{{ .grpcName }}"
  envoyExtAuthzGrpc:
    service: "{{ .grpcHost }}"
    port: {{ .grpcPort }}`

	localServiceEntryTemplate = `

 */
package org.gradle.nativeplatform.toolchain;

import org.gradle.api.Action;
import org.gradle.api.Incubating;

import java.io.File;
import java.util.List;

/**
 * A ToolChain that can handle additional platforms simply by configuring the NativeBinary.
 */
@Incubating
public interface GccCompatibleToolChain extends NativeToolChain {
    /**
     * The paths setting required for executing the tool chain.

     *
     * If a configuration with this name already exists this method will <strong>overwrite</strong> its current usage to match what
     * would be set if the configuration needed to be created; it will emit an additional deprecation warning when doing this.
     */
    Configuration maybeCreateResolvableUnlocked(String name);

    /**
     * If a configuration with the given name already exists, return it.

var (
	CompliancePolicy = env.Register("COMPLIANCE_POLICY", "",
		`If set, applies policy-specific restrictions over all existing TLS
settings, including in-mesh mTLS and external TLS. Valid values are:

* '' or unset places no additional restrictions.
* 'fips-140-2' which enforces a version of the TLS protocol and a subset
of cipher suites overriding any user preferences or defaults for all runtime
components, including Envoy, gRPC Go SDK, and gRPC C++ SDK.

# Monitor

This package provides the ability to populate a `crd.Controller` dynamically via a function that provides
additional config. The monitor will acquire snapshots of additional changes and populate the `crd.Controller`
as needed.

## Creating a Monitor

To create a monitor, you should provide the `crd.Controller`, a polling interval, and
a function that returns `[]*model.Config`.

```golang
monitor := file.NewMonitor(

            }
        """.stripIndent()

        expect:
        succeeds('checkClasspath')
    }

    def "can compile against compile only dependencies for additional source sets"() {
        given:
        file('src/additional/java/Test.java') << """
            import org.apache.commons.logging.Log;
            import org.apache.commons.logging.LogFactory;

            public class Test {

executable: gradle
args: tasks
expected-output-file: taskGroupDescription.out

executable: gradle
args: dependencies
expected-output-file: dependencies.out