<trusted-key id="47504B76CF89C15C0512D9AFE16AB52D79FD224F" group="^com[.]google($|([.].*))" regex="true"/>
         <trusted-key id="475F3B8E59E6E63AA78067482C7B12F2A511E325">
            <trusting group="ch.qos.logback"/>
            <trusting group="org.slf4j"/>
            <trusting group="org.slf4j" name="slf4j-api"/>
         </trusted-key>
         <trusted-key id="4DB1A49729B053CAF015CEE9A6ADFC93EF34893E" group="org.hamcrest"/>

deveshkandpal1224 <******@****.***> 1717646003 -0700

        factory.inetAddresses = addresses
    }

    def "Loopback addresses are preferred"() {
        when:
        def loopback = [ip(127, 0, 0, 1)]
        loopbackAddresses(loopback)
        remoteAddresses([ip(192, 168, 17, 256)])

        then:
        factory.communicationAddresses == loopback
    }

    def "Use remote addresses if there are no loopback addresses"() {
        when:
        loopbackAddresses([])

                        logger.debug("Adding loopback address {}", candidate);
                        loopback.add(candidate);
                    } else {
                        logger.debug("Ignoring remote address on loopback interface {}", candidate);
                    }
                } else {
                    if (candidate.isLoopbackAddress()) {
                        logger.debug("Ignoring loopback address on remote interface {}", candidate);

    def addresses = new InetAddresses()

    def "always contains at least one loopback address"() {
        expect:
        !addresses.loopback.empty
    }

    @Requires(UnitTestPreconditions.Online)
    def "always contains at least one remote address"() {
        expect:
        !addresses.remote.empty
    }

    def "No remote addresses are loopback addresses"() {
        expect:

Ben Leggett <******@****.***> 1710179183 -0400

        findCommunicationAddresses();

        handleOpenshift();
    }

    /**
     * Prefer first loopback address if available, otherwise use the wildcard address.
     */
    private void findLocalBindingAddress() {
        if (inetAddresses.getLoopback().isEmpty()) {
            logger.debug("No loopback address for local binding, using fallback {}", wildcardBindingAddress);

	if ifi == nil {
		b.Skip("loopback interface not found")
	}
	for i := 0; i < b.N; i++ {
		if _, err := InterfaceByIndex(ifi.Index); err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkInterfaceByName(b *testing.B) {
	b.ReportAllocs()
	testHookUninstaller.Do(uninstallTestHooks)

	ifi := loopbackInterface()
	if ifi == nil {
		b.Skip("loopback interface not found")
	}

			ExpectedCertIndex: 0,
		},
		"loopback: LoopbackClientServerNameOverride on SNI cert": {
			Cert: TestCertSpec{
				host: "localhost",
			},
			SNICerts: []NamedTestCertSpec{
				{
					TestCertSpec: TestCertSpec{
						host: server.LoopbackClientServerNameOverride,
					},
				},
			},
			ExpectedCertIndex: -1,
		},
		"loopback: bind to 0.0.0.0 => loopback uses localhost": {
			Cert: TestCertSpec{

apiVersion: release-notes/v2
kind: feature
area: traffic-management

issue:
  - 47211

releaseNotes:
- |