import org.gradle.internal.Factory;

/**
 * A specialized version of multi cause exception that is cheaper to create
 * because we avoid to fill a stack trace, and the message MUST be generated lazily.
 */
@Contextual
public class DefaultMultiCauseExceptionNoStackTrace extends DefaultMultiCauseException {
    public DefaultMultiCauseExceptionNoStackTrace(Factory<String> messageFactory) {
        super(messageFactory);

class ConfigurationCacheFileTreeIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    @Issue('https://github.com/gradle/gradle/issues/19780')
    def "filter predicates and matching patterns are evaluated lazily"() {
        given:
        buildFile """
            abstract class PrintInputs extends DefaultTask {

                @InputFiles
                abstract ConfigurableFileCollection getInputFiles()

import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name

/**
 * Implements [KaNamedClassOrObjectSymbol] for a Java class. The underlying [firSymbol] is built lazily and only when needed. Many simple
 * properties are computed from the given [PsiClass] instead of [firSymbol]. This improves performance when "slow" properties don't need to
 * be accessed.
 */

        Gradle gradle
    ) {
        this.instantiator = instantiator;
        // Shared services must be provided lazily, otherwise they are instantiated too early and some cases can fail
        this.instrumentationTransformRegisterer = new InstrumentationTransformRegisterer(agentStatus, Lazy.atomic().of(gradle::getSharedServices));
    }

    @Override

                    declarationDescriptor.upperBounds.any { it.hasReferenceOtherThan(allowedTypeParameterDescriptors) }
        }
        else -> arguments.any { typeProjection ->
            // A star projection type (lazily) built by type parameter will be yet another type with a star projection,
            // resulting in stack overflow if we keep checking allowed type parameter descriptors
            !typeProjection.isStarProjection &&

	r.SetScalar(name, r.ScalarResources[name]+quantity)
}

// SetScalar sets a resource by a scalar value of this resource.
func (r *Resource) SetScalar(name v1.ResourceName, quantity int64) {
	// Lazily allocate scalar resource map.
	if r.ScalarResources == nil {
		r.ScalarResources = map[v1.ResourceName]int64{}
	}
	r.ScalarResources[name] = quantity
}

  tensorflow::XlaCallModuleLoader* loader;
  if (auto it = xla_call_module_loaders_.find(op);
      it != xla_call_module_loaders_.end()) {
    loader = it->second.get();
  } else {
    // Lazily parse XlaCallModule's embedded HLO module and cache the loader to
    // avoid repeatedly parsing the module.

    std::vector<std::string> disabled_checks;

		for family, cidrs := range proxyutil.MapCIDRsByIPFamily(clusterCIDRs) {
			localDetectors[family] = proxyutil.NewDetectLocalByCIDR(cidrs[0].String())
		}
		if !localDetectors[primaryIPFamily].IsImplemented() {
			logger.Info("Detect-local-mode set to ClusterCIDR, but no cluster CIDR specified for primary IP family", "ipFamily", primaryIPFamily, "clusterCIDR", config.ClusterCIDR)
		}

            value.value
        }
    }

    @Test
    fun `forces evaluation of static Lazy fields`() {
        assertEagerEvaluationOf(LazyBean(lazy())) {
            value.value
        }
    }

    @Test
    fun `forces evaluation of by lazy properties`() {
        assertEagerEvaluationOf(ByLazyBean()) {
            value
        }
    }

    private

 * limitations under the License.
 */

package org.gradle.internal.instrumentation.agent;

import org.gradle.internal.lazy.Lazy;

class DefaultAgentStatus implements AgentStatus {

    private static final Lazy<Boolean> IS_AGENT_INSTRUMENTATION_ENABLED = Lazy.locking().of(AgentControl::isInstrumentationAgentApplied);

    @Override
    public boolean isAgentInstrumentationEnabled() {