binary.targetPlatform == targetPlatform
        binary.toolChain == toolChain
        binary.platformToolProvider == platformToolProvider

        app.binaries.realizeNow()
        app.binaries.get() == [binary] as Set
    }

    def "throws exception when development binary is not available"() {
        given:
        app.binaries.realizeNow()

        when:
        app.developmentBinary.get()

        then:

                task.getWorkingDirectory().set(binary.getInstallDirectory());
            });
            binary.getRunTask().set(testingTask);

            configureTestSuiteBuildingTasks(project, binary);
            configureTestSuiteWithTestedComponentWhenAvailable(project, testComponent, binary);
        });

        project.afterEvaluate(p -> {

ISTIO_ENVOY_LINUX_RELEASE_PATH="${ISTIO_ENVOY_LINUX_RELEASE_PATH:-${ISTIO_ENVOY_LINUX_RELEASE_DIR}/${ISTIO_ENVOY_LINUX_RELEASE_NAME}}"

# There is no longer an Istio built Envoy binary available for the Mac. Copy the Linux binary as the Mac binary was
# very old and likely no one was really using it (at least temporarily).

# Download Envoy debug and release binaries for Linux x86_64. They will be included in the

		if cidr.IP.To4() != nil {
			ipInt := binary.BigEndian.Uint32(cidr.IP) | (^binary.BigEndian.Uint32(cidr.Mask))
			binary.BigEndian.PutUint32(ip, ipInt)
		} else {
			// ipIntLeft          |         ipIntRight
			// 2001:0DB8:1234:0000:0000:0000:0000:0000
			ipIntLeft := binary.BigEndian.Uint64(cidr.IP[:net.IPv6len/2]) | (^binary.BigEndian.Uint64(cidr.Mask[:net.IPv6len/2]))

        def binary = new File("any")
        when:
        def metadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        interaction compilerShouldBeExecuted

        when:
        def newMetadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        0 * _

    }
    tasks {
        verify(Task) {
            doLast {
                def comp = $.components.mylib
                def binary = comp.binaries.main
                assert comp.sources.size() == 1
                assert binary.sources.size() == 1
                assert binary.inputs == comp.sources + binary.sources as Set
            }
        }
    }
}
'''

        expect:
        succeeds "verify"
    }

FROM --platform=linux/$BUILDARCH ${SETCAP_IMAGE}
ARG BINARY
COPY ${BINARY} /${BINARY}
# We apply cap_net_bind_service so that kube-apiserver can be run as
# non-root and still listen on port less than 1024
RUN setcap cap_net_bind_service=+ep /${BINARY}

FROM --platform=linux/$TARGETARCH ${BASEIMAGE}
ARG BINARY

//
// Basic selection logic is as follows:
// 1. see if we have `nft` binary set in our $PATH
// 2. see if we have existing rules in `nft` in our netns
// 3. If so, use `nft` binary set
// 4. Otherwise, see if we have `legacy` binary set, and use that.
// 5. Otherwise, see if we have `iptables` binary set, and use that (detecting whether it's nft or legacy).

exec $WORK/lib/goroot/bin/go list -f '{{.ImportPath}}: {{.Dir}}' encoding/binary
stdout '^encoding/binary: '$WORK${/}lib${/}goroot${/}src${/}encoding${/}binary'$'

exec $WORK/lib/goroot/bin/go list -f '{{.ImportPath}}: {{.Dir}}' std
stdout '^encoding/binary: '$WORK${/}lib${/}goroot${/}src${/}encoding${/}binary'$'

# Most path lookups in GOROOT are not sensitive to symlinks. However, patterns

 *          //building the binary
 *      }
 * }
 *
 * class MyCustomBinariesPlugin extends RuleSource {
 *     {@literal @}ComponentType
 *     void register(TypeBuilder<SampleBinary> builder) {}
 *
 *     {@literal @}BinaryTasks
 *     void createBinaryTasks(ModelMap<Task> tasks, SampleBinary binary) {
 *         tasks.create("${binary.name}Task1", MyCustomBinaryCreationTask)