import org.junit.Test
import java.util.concurrent.Callable


class CallableCodecTest : AbstractFunctionalTypeTest() {

    @Test
    fun `defers evaluation of Callable objects`() {
        assertDeferredEvaluationOf(callable()) {
            call()
        }
    }

    @Test
    fun `defers evaluation of dynamic Callable fields`() {

import org.junit.Test
import java.util.function.Supplier


class SupplierCodecTest : AbstractFunctionalTypeTest() {

    @Test
    fun `defers evaluation of Supplier objects`() {
        assertDeferredEvaluationOf(supplier()) {
            get()
        }
    }

    @Test
    fun `defers evaluation of dynamic Supplier fields`() {

		return true
	}

	// permit if object resides in a namespace labeled for discovery
	return d.discoveryNamespaces.Contains(ns)
}

func extractObjectNamespace(obj any) (string, bool) {
	if ns, ok := obj.(string); ok {
		return ns, true
	}
	object := controllers.ExtractObject(obj)
	if object == nil {
		// When an object is deleted, obj could be a DeletionFinalStateUnknown marker item.
		return "", false
	}

//   snowball:
//     disable: false # optionally turn-off snowball archive transfer
//     batch: 100 # upto this many objects per archive
//     inmemory: true # indicates if the archive must be staged locally or in-memory
//     compress: true # S2/Snappy compressed archive
//     smallerThan: 5MiB # create archive for all objects smaller than 5MiB
//     skipErrs: false # skips any source side read() errors

abstract class EnvVariableInjection extends BuildInputInjection {
    static EnvVariableInjection environmentVariable(String key, String value) {
        return environmentVariables((key): Objects.requireNonNull(value))
    }

    static EnvVariableInjection environmentVariables(Map<String, String> variables) {
        return new EnvVariableInjection() {
            @Override
            String getDescription() {

/**
 * [Lazy] values support Java serialization via a custom `writeReplace` method that forces their evaluation.
 */
class LazyCodecTest : AbstractFunctionalTypeTest() {

    @Test
    fun `forces evaluation of Lazy objects`() {
        assertEagerEvaluationOf(lazy()) {
            value
        }
    }

    @Test
    fun `forces evaluation of dynamic Lazy fields`() {
        assertEagerEvaluationOf(BeanOf(lazy())) {

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Plugins, tasks and domain objects for testing native code"

errorprone {
    disabledChecks.addAll(
        "MixedMutabilityReturnType", // 1 occurrences
    )
}

dependencies {
    api(projects.serviceProvider)
    api(project(":base-services"))
    api(project(":core"))
    api(project(":core-api"))
    api(project(":diagnostics"))

 *  </p>
 *  <p>
 *      Object serialization is a graph-walking process, and as such, it has a recursive nature.
 *  </p>
 *  <p></p>
 *      In order to serialize one object, {@link  org.gradle.internal.serialize.graph.WriteContext#write(java.lang.Object, kotlin.coroutines.Continuation) WriteContext.write(object)} must be invoked.
 *  </p>

 */
package org.apache.maven.internal.impl;

import java.io.IOException;
import java.nio.file.Path;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;

import org.apache.maven.api.*;
import org.apache.maven.api.Artifact;
import org.apache.maven.api.ArtifactCoordinate;

import org.gradle.internal.configuration.problems.ProblemFactory
import org.gradle.internal.configuration.problems.ProblemsListener
import org.gradle.internal.extensions.stdlib.capitalized
import org.gradle.util.Path
import java.util.Objects
import java.util.function.BiConsumer


internal
class CrossProjectConfigurationReportingTaskExecutionGraph(
    taskGraph: TaskExecutionGraphInternal,
    private val referrerProject: ProjectInternal,