},
			name: "not enough cpu and memory resource",
		},
		{
			pod: &v1.Pod{
				Spec: v1.PodSpec{
					NodeName: "machine2",
				},
			},
			nodeInfo: schedulerframework.NewNodeInfo(),
			node: &v1.Node{
				ObjectMeta: metav1.ObjectMeta{Name: "machine1"},
				Status:     v1.NodeStatus{Capacity: makeResources(10, 20, 32, 0, 0, 0), Allocatable: makeAllocatableResources(10, 20, 32, 0, 0, 0)},
			},

				Target:     api.ObjectReference{Name: "machine1", Kind: "unknown"},
			},
			errOK: func(err error) bool { return err != nil },
		},
		"emptyKind": {
			binding: api.Binding{
				ObjectMeta: metav1.ObjectMeta{Namespace: metav1.NamespaceDefault, Name: "foo"},
				Target:     api.ObjectReference{Name: "machine2"},
			},
			errOK: func(err error) bool { return err == nil },
		},

        and:
        buildFile << configureTargetMachines("machines.linux", "machines.macOS", "machines.windows")

        expect:
        succeeds taskNameToAssembleDevelopmentBinary
        result.assertTasksExecutedAndNotSkipped getTasksToAssembleDevelopmentBinary(currentOsFamilyName.toLowerCase()), ":${taskNameToAssembleDevelopmentBinary}"
    }

    @RequiresInstalledToolChain(ToolChainRequirement.SUPPORTS_32_AND_64)

                }

                components.withType(CppComponent) {
                    linkage = [Linkage.STATIC]
                    targetMachines = [machines.windows.architecture('${currentArchitecture}'), machines.linux.architecture('${currentArchitecture}'), machines.macOS.architecture('${currentArchitecture}')]
                }
            }
            project(':deck') {
                dependencies {

        Assume.assumeFalse(componentUnderTestDsl == null)

        given:
        makeSingleProject()
        writeTests()
        configureTargetMachines("machines.os('${currentOsFamilyName}').x86, machines.os('${currentOsFamilyName}').x86_64")
        configureTestTargetMachines("machines.os('${currentOsFamilyName}').x86_64")

Target machines - defaults to the build host::
The target machine expresses which machines the application expects to run.
A target machine is identified by its operating system and architecture.
Gradle uses the target machine to decide which tool chain to choose based on availability on the host machine.

The target machine can be configured as follows:

.Configure application target machines

    def "ignores duplicate target machines"() {
        given:
        makeSingleProject()
        settingsFile << "rootProject.name = '${componentUnderTest.projectName}'"
        componentUnderTest.writeToProject(testDirectory)

        and:
        buildFile << configureTargetMachines("machines.${currentHostOperatingSystemFamilyDsl}", "machines.${currentHostOperatingSystemFamilyDsl}")
        buildFile << """

Target machines - defaults to the tested component (if present) or build host (otherwise)::
The target machine expresses which machines the application expects to run.
A target machine is identified by its operating system and architecture.
Gradle uses the target machine to decide which tool chain to choose based on availability on the host machine.

The target machine can be configured as follows:

Target machines - defaults to the tested component (if present) or build host (otherwise)::
The target machine expresses which machines the application expects to run.
A target machine is identified by its operating system and architecture.
Gradle uses the target machine to decide which tool chain to choose based on availability on the host machine.

The target machine can be configured as follows:

import spock.lang.Specification

class DefaultTargetMachineFactoryTest extends Specification {
    def factory = new DefaultTargetMachineFactory(TestUtil.objectFactory())

    def "can use created target machines in Set"() {
        def windows1 = factory.windows
        def windows2 = factory.windows
        def linux1 = factory.linux.x86_64
        def linux2 = factory.linux.x86_64

        expect: