System_Ext(buildCache, "Gradle Build Cache", "Local, Develocity Build Cache Node, etc...")

Rel(dev, gradle, "Uses", "Command Line")
Rel(dev, editor, "Uses", "GUI")

Rel(provider, kotlinc, "Uses", "Embedded")
Rel(plugin, kgp, "Applies")

Rel(ideKotlin, kotlinc, "Uses")
Rel(ideKotlin, resolver, "Loads", "Embedded")

Rel(provider, buildCache, "Uses")
Rel(kgp, buildCache, "Uses")

import spock.lang.Issue

class CommonToolChainIntegrationTest extends AbstractInstalledToolChainIntegrationSpec {
    @Issue("https://github.com/gradle/gradle-native/issues/139")
    @ToBeFixedForConfigurationCache
    def "can rely on working directory to be project directory"() {
        def app = new CHelloWorldApp()

        given:
        buildFile << """
apply plugin: 'c'

model {
    components {
        main(NativeExecutableSpec) {

    %1 = "tf.Relu6"(%0) : (tensor<*xf32>) -> tensor<*xf32>
    func.return %1 : tensor<*xf32>
  }
}

// CalibrationOptions(calibration_method=CALIBRATION_METHOD_MIN_MAX)
// MIN-MAX-CHECK: func @wrap_composite_func

#include "tensorflow/core/framework/types.h"
#include "tensorflow/core/lib/core/status.h"

namespace tensorflow {

// An OpKernel that compiles an op to an XLA computation and runs it. Unlike
// XlaLaunch this doesn't rely on any rewrites of the graphdef - it will run a
// vanilla TensorFlow op as long as the bridge supports it.
class XlaCompileOnDemandOp : public OpKernel {
 public:
  explicit XlaCompileOnDemandOp(OpKernelConstruction* ctx)

      you've completed your Istio upgrade, you can change the label selector in `Deployment` and `Service` resources whenever you are

    %6 = "quantfork.stats"(%5) {layerStats = dense<[-2788.31055, 4616.62842]> : tensor<2xf32>} : (tensor<*xf32>) -> tensor<*xf32>
    %7 = "tf.Relu6"(%6) {device = ""} : (tensor<*xf32>) -> tensor<*xf32>
    %8 = "quantfork.stats"(%7) {layerStats = dense<[0.000000e+00, 6.000000e+00]> : tensor<2xf32>} : (tensor<*xf32>) -> tensor<*xf32>
    return %8 : tensor<*xf32>
  }

     * provided model directly or to create a clone of the model and interpolate the clone. Callers should always use
     * the returned model and must not rely on the input model being updated.
     *
     * @param model The model to interpolate, must not be {@code null}.
     * @param projectDir The project directory, may be {@code null} if the model does not belong to a local project but

                + transformer.getEstimatedSingleLambdaHandlingCodeLength(lambdaArgs as Type[])
        )

        then:
        // ASM has no API to figure out the exact method size, so we have to rely on estimations.
        estimatedDeserializationMethodSize == getMaxEvaluatedDeserializationMethodSize(classWriter.toByteArray())

        where:
        cl                             | lambdaArgs

     * resources
     */
    JvmEcosystemAttributesDetails asJar();

    /**
     * Configures the target JVM version. For producers of a library, it's in general
     * a better idea to rely on inference which will calculate the target JVM version
     * lazily, for example calling {@code JvmLanguageUtilities#useDefaultTargetPlatformInference(Configuration, TaskProvider)}.

        Settings::class,
        isTopLevelPluginManagementBlock,
        schemaComponents = EvaluationSchemaBuilder::gradleDslGeneralSchema
    )


/** TODO: Instead of [SettingsInternal], this should rely on the public API of [Settings];
 *  missing single-arg [Settings.include] (or missing vararg support) prevents this from happening,
 *  and we use the [SettingsInternal.include] single-argument workaround for now. */
internal