//go:build amd64

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

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:

            application {
                baseName = 'test'
                targetMachines = [machines.windows.x86, machines.linux.x86, machines.macOS.x86_64]
            }
            publishing {
                repositories { maven { url '$mavenRepo.uri' } }
            }
        """
        app.writeToProject(testDirectory)

        when:
        run('publish')

        then:

     *
     * @param action the action to execute on incoming connection. The supplied action is not required to be thread-safe.
     * @param allowRemote If true, only allow connections from remote machines. If false, allow only from the local machine.
     * @return the address of the endpoint which the connector is listening on.
     */
    ConnectionAcceptor accept(Action<ConnectCompletion> action, boolean allowRemote);

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

            application.targetMachines = [machines.${currentHostOperatingSystemFamilyDsl}.x86, machines.${currentHostOperatingSystemFamilyDsl}.x86_64]
        """

        def app = new CppApp()
        app.writeToProject(testDirectory)
        file('src/main/headers/ignore.cpp') << 'broken!'

        makeSingleProject()
        componentUnderTest.writeToProject(testDirectory)

        and:
        buildFile << configureTargetMachines("machines.os('some-other-family')")

        expect:
        succeeds "help"
    }

    def "fails configuration when no target machine is configured"() {
        given:
        makeSingleProject()
        componentUnderTest.writeToProject(testDirectory)

        and:

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:

                    publicHeaders.from('src/main/headers')
                    targetMachines = [machines.host().x86]
                }
            }
            project(':app') {
                apply plugin: 'cpp-application'
                application {
                    targetMachines = [machines.host().x86]
                }
                dependencies {
                    implementation project(':library')

	PushThrottle = func() int {
		v := env.Register(
			"PILOT_PUSH_THROTTLE",
			0,
			"Limits the number of concurrent pushes allowed. On larger machines this can be increased for faster pushes. "+
				"If set to 0 or unset, the max will be automatically determined based on the machine size",
		).Get()
		if v > 0 {
			return v
		}
		procs := runtime.GOMAXPROCS(0)
		// Heuristic to scale with cores. We end up with...
		// 1: 20

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: