res := []string{}
	if svc.Spec.ClusterIP != "" && svc.Spec.ClusterIP != v1.ClusterIPNone {
		res = append(res, svc.Spec.ClusterIP)
	}
	for _, ing := range svc.Status.LoadBalancer.Ingress {
		// IPs are strictly optional for loadbalancers - they may just have a hostname.
		if ing.IP != "" {
			res = append(res, ing.IP)
		}
	}
	return res

import org.gradle.api.Action;

import java.io.InputStream;

/**
 * Provides access to resources on an artifact repository. Gradle takes care of caching
 * the resources locally. The scope of the cache may depend on the accessor: users should
 * refer to the javadocs of the methods providing an accessor to determine the scope.
 *
 * @since 4.0
 */
public interface RepositoryResourceAccessor {
    /**

	}
	os.Setenv("PWD", modRoot)
	if err := os.WriteFile("go.mod", []byte("module cgostdio\n"), 0666); err != nil {
		log.Panic(err)
	}

	return m.Run()
}

// TestTestRun runs a cgo test that doesn't depend on non-standard libraries.
func TestTestRun(t *testing.T) {
	testenv.MustHaveGoRun(t)
	testenv.MustHaveCGO(t)

	for _, file := range [...]string{
		"chain.go",
		"fib.go",
		"hello.go",
	} {
		file := file

import org.gradle.test.preconditions.UnitTestPreconditions

@Requires(UnitTestPreconditions.Jdk9OrLater)
class EclipseJavaProjectModulesIntegrationTest extends AbstractEclipseIntegrationSpec {

    def "depend on modular project"() {
        setup:
        /*
        This is the multi-module project structure the integration test works with:
        -root
          -api
          -util
        */

// LastAppliedConfigAnnotation is the annotation used to store the previous
// configuration of a resource for use in a three way diff by UpdateApplyAnnotation.
//
// This is a copy of the corev1 annotation since we don't want to depend on the whole package.
const LastAppliedConfigAnnotation = "kubectl.kubernetes.io/last-applied-configuration"

// SetLastApplied sets the last-applied annotation the given value in
// the object.

  LazyLogger(Class<?> ownerOfLogger) {
    this.loggerName = ownerOfLogger.getName();
  }

  Logger get() {
    /*
     * We use double-checked locking. We could the try racy single-check idiom, but that would
     * depend on Logger not contain mutable state.
     *
     * We could use Suppliers.memoizingSupplier here, but I micro-optimized to this implementation

# and `k8s.io/release/lib/releaselib.sh` must be manually updated with the changes.
# We HIGHLY recommend not changing the file structure, because consumers of
# Kubernetes releases depend on the release structure remaining stable.

$ErrorActionPreference = 'Stop'

# Turn on tracing to debug
# Set-PSDebug -Trace 1

# Update TLS setting to enable Github downloads and disable progress bar to

# Regression test for issue #48557.
# Since builds in module mode do not support relative imports at all, the build
# ID for (and other contents of) a binary built with -trimpath in module mode
# should not depend on its working directory, even if the binary is specified as
# a list of relative source files.

[short] skip  # links and runs binaries

env GOFLAGS=-trimpath
env GOCACHE=$WORK/gocache

import org.gradle.model.Model;
import org.gradle.model.ModelMap;
import org.gradle.model.Mutate;
import org.gradle.model.RuleSource;

/**
 * These bindings are only here for backwards compatibility, as some users might depend on the extensions being available in the model.
 */
class PublishingPluginRules extends RuleSource {
    @Model
    PublishingExtension publishing(ExtensionContainer extensions) {

        // Direct dependencies should be computed lazily, because the built-ins module will be reachable via module dependencies. Getting
        // the built-ins module relies on the built-ins session, which may depend on services that are registered after
        // `KtStaticModuleDependentsProvider`.
        buildDependentsMap(modules) { it.allDirectDependencies() }
    }