private final FileSystemOperations fs;
    private final JacocoAgentJar agent;

    private String toolVersion;
    private final DirectoryProperty reportsDirectory;

    /**
     * Creates a Jacoco plugin extension.
     *
     * @param project the project the extension is attached to
     * @param agent the agent JAR to be used by Jacoco
     */
    @Inject

    TF_CoordinationServiceAgent* agent);

TF_CAPI_EXPORT extern void TF_CoordinationServiceInsertKeyValue(
    const char* key, int64_t key_size, const char* value, int64_t value_size,
    TF_CoordinationServiceAgent* agent, TF_Status* status);

// Obtains key-value from coordination service agent. The returned `TF_Buffer`
// is a newly allocated buffer to hold the string key-value, and caller is

    assertFailsWith<NullPointerException> {
      (mapOf("User-Agent" to null) as Map<String, String>).toHeaders()
    }
  }

  @Test fun toMultimapGroupsHeaders() {
    val headers =
      Headers.headersOf(
        "cache-control",
        "no-cache",
        "cache-control",
        "no-store",
        "user-agent",
        "OkHttp",
      )
    val headerMap = headers.toMultimap()

# Binds above cluster role to spire-agent service account.
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: spire-agent-cluster-role-binding
subjects:
- kind: ServiceAccount
  name: spire-agent
  namespace: spire
roleRef:
  kind: ClusterRole
  name: spire-agent-cluster-role
  apiGroup: rbac.authorization.k8s.io

---
# ConfigMap for the SPIRE agent featuring:

			config: &meshconfig.MeshConfig_ExtensionProvider_DatadogTracingProvider{
				Service: "datadog-agent.com",
				Port:    8126,
			},
			valid: true,
		},
		{
			name: "datadog service with namespace",
			config: &meshconfig.MeshConfig_ExtensionProvider_DatadogTracingProvider{
				Service: "namespace/datadog-agent.com",
				Port:    8126,
			},
			valid: true,
		},
		{

        javaAgentProjectDir.file('src/main/java/Agent.java').text = javaAgentClassContent
        javaAgentProjectDir.file('build.gradle').text = buildScriptContent
    }

    String getJavaAgentClassContent() {
        return """
            import java.lang.instrument.Instrumentation;

            public class Agent {
                public static void premain(String args, Instrumentation instrumentation){

public interface AgentStatus {
    /**
     * Checks if the agent-based bytecode instrumentation is enabled for the current JVM process.
     *
     * @return {@code true} if the agent instrumentation should be used
     */
    boolean isAgentInstrumentationEnabled();

    /**
     * Returns an AgentStatus instance that enables instrumentation if the agent is available.
     */
    static AgentStatus allowed() {

import javax.annotation.Nullable;
import java.security.ProtectionDomain;

/**
 * A ClassLoader implementing this interface gets a special treatment from the instrumenting Java agent.
 * When such a classloader attempts to define a class, the agent calls {@link #instrumentClass(String, ProtectionDomain, byte[])} method
 * giving the classloader a chance to rewrite the bytecode of the class.
 * <p>

 * limitations under the License.
 */

package org.gradle.internal.instrumentation.agent;

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Initializes the instrumenting agent.
 */
@ServiceScope(Scope.Global.class)
public class AgentInitializer {
    private final AgentStatus agentStatus;

func (p *XdsProxy) getTLSOptions(agent *Agent) (*istiogrpc.TLSOptions, error) {
	if agent.proxyConfig.ControlPlaneAuthPolicy == meshconfig.AuthenticationPolicy_NONE {
		return nil, nil
	}
	xdsCACertPath, err := agent.FindRootCAForXDS()
	if err != nil {
		return nil, fmt.Errorf("failed to find root CA cert for XDS: %v", err)
	}
	key, cert := agent.GetKeyCertsForXDS()
	return &istiogrpc.TLSOptions{