Linux containers run using the same Linux kernel of the host (machine, virtual machine, cloud server, etc). This just means that they are very lightweight (compared to full virtual machines emulating an entire operating system).

This way, containers consume **little resources**, an amount comparable to running the processes directly (a virtual machine would consume much more).

package platform

import (
	"fmt"
	"reflect"
	"testing"
)

// Mock responses for Azure Metadata (based on Microsoft API documentation samples)
// https://docs.microsoft.com/en-us/azure/virtual-machines/windows/instance-metadata-service
const (
	MockVersionsTemplate = `{"error": "Bad request. api-version was not specified in the request","newest-versions": ["%s"]}`

Beginning with the build cache on CI is a good first step as the environment on CI agents is usually more stable and predictable than developer machines.
This helps to identify any possible issues with the build that may affect cacheability.

        BELLSOFT("bellsoft", "BellSoft Liberica"),
        GRAAL_VM("graalvm community", "GraalVM Community"),
        HEWLETT_PACKARD("hewlett-packard", "HP-UX"),
        IBM("ibm", "ibm|international business machines corporation", "IBM"),
        JETBRAINS("jetbrains", "JetBrains"),
        MICROSOFT("microsoft", "Microsoft"),
        ORACLE("oracle", "Oracle"),
        SAP("sap se", "SAP SapMachine"),

// A job object is used here so that any spawned processes such as powershell or
// wmic are created at the specified thread priority class.
// Running kubelet with above normal / high priority  can help improve
// responsiveness on machines with high CPU utilization.
func createWindowsJobObject(pc uint32) (windows.Handle, error) {
	job, err := windows.CreateJobObject(nil, nil)
	if err != nil {

fi
# VERY basic check to ensure the [and-cuda] package variant is installable.
# Checks TFCI_BAZEL_COMMON_ARGS for "gpu" or "cuda", implying that the test is
# relevant. All of the GPU test machines have CUDA installed via other means,
# so I am not sure how to verify that the dependencies themselves are valid for
# the moment.
if [[ "$TFCI_BAZEL_COMMON_ARGS" =~ gpu|cuda ]]; then

        def releaseBinary = exe("build/exe/main/release/macos/App")

        given:
        buildFile << """
            apply plugin: 'swift-application'

            application.targetMachines = [machines.macOS, machines.linux]
        """

        app.writeToProject(testDirectory)
        //executer.startBuildProcessInDebugger(true)
        succeeds("xcode")

        when:
        debugBinary.assertDoesNotExist()

title: TensorFlow, Large-scale machine learning on heterogeneous systems

    def "can create xcode project for unbuildable swift component with #sourceCompatibility source compatibility"() {
        given:
        makeSingleProject()
        buildFile << configureTargetMachines("machines.os('os-family')")
        buildFile << """
            ${componentUnderTestDsl}.sourceCompatibility = ${sourceCompatibility}
        """
        componentUnderTest.writeToProject(testDirectory)

        when:

                    .severity(Severity.ERROR)
                    .details("If you don't declare the normalization, outputs can't be re-used between machines or locations on the same machine, therefore caching efficiency drops significantly")
                    .solution("Declare the normalization strategy by annotating the property with either @PathSensitive, @Classpath or @CompileClasspath");