rootProject.gradleSourceRoots()
    }

    val classPathModeExceptions: List<Exception> by unsafeLazy {
        rootProject.serviceOf<ClassPathModeExceptionCollector>().exceptions
    }

    val implicitImports: List<String> by unsafeLazy {
        rootProject.serviceOf<ImplicitImports>().list
    }

    val nonProjectScriptPaths: ScriptClassPath by unsafeLazy {
        ScriptClassPath(

metadata:
  resourceVersion: ""`
	udpService = `
kind: Service
metadata:
  name: hello
spec:
  ports:
    -
      protocol: udp`
	skippedService = `
kind: Service
metadata:
  name: hello
  namespace: istio-system
spec:
  ports:
    -
      name: http
      port: 9080`
	validPortNamingSvc = `
apiVersion: v1
kind: Service
metadata:
  name: hello
spec:
  ports:

        val dependencyManagementServices = gradle.serviceOf<DependencyManagementServices>()
        val fileCollectionFactory = gradle.serviceOf<FileCollectionFactory>()
        val dependencyResolutionServices = dependencyManagementServices.create(
            gradle.serviceOf<FileResolver>(),
            fileCollectionFactory,
            gradle.serviceOf<DependencyMetaDataProvider>(),

        "gradleKotlinDsl"
    )


internal
fun Project.fileCollectionOf(files: Collection<File>, name: String): FileCollection =
    serviceOf<FileCollectionFactory>().fixed(name, files)


internal
fun kotlinScriptClassPathProviderOf(project: Project) =
    project.serviceOf<KotlinScriptClassPathProvider>()


internal
typealias JarsProvider = () -> Collection<File>


class KotlinScriptClassPathProvider(

			}}
		}),
	)
	fp.syncProxyRules()

	// check ipvs service and destinations
	services, err := ipvs.GetVirtualServers()
	if err != nil {
		t.Errorf("Failed to get ipvs services, err: %v", err)
	}
	if len(services) != 2 {
		t.Errorf("Expect 2 ipvs services, got %d", len(services))
	}
	found := false
	for _, svc := range services {

import org.gradle.api.reporting.Reporting
import org.gradle.api.tasks.testing.Test
import org.gradle.build.event.BuildEventsListenerRegistry
import org.gradle.kotlin.dsl.*
import org.gradle.kotlin.dsl.support.serviceOf
import java.io.File


class TestFilesCleanupRootPlugin : Plugin<Project> {
    override fun apply(project: Project) {
        require(project.rootProject == project) { "This plugin should be applied to root project!" }

import org.gradle.kotlin.dsl.support.serviceOf


/**
 * Exposes `*.gradle.kts` scripts from regular Kotlin source-sets as binary Gradle plugins.
 *
 * @see PrecompiledScriptPluginsSupport
 */
abstract class PrecompiledScriptPlugins : Plugin<Project> {

    override fun apply(project: Project): Unit = project.run {

        if (serviceOf<PrecompiledScriptPluginsSupport>().enableOn(Target(project))) {

import org.gradle.api.Project

import org.gradle.api.internal.classpath.ModuleRegistry
import org.gradle.internal.classpath.ClassPath
import org.gradle.kotlin.dsl.support.serviceOf

import java.io.File
import java.io.Serializable


internal
object KotlinBuildScriptTemplateModelBuilder : ToolingModelBuilder {

    private

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

	return []corev1.ScopedResourceSelectorRequirement{}, nil
}

// convert the input object to an internal service object or error.
func toExternalServiceOrError(obj runtime.Object) (*corev1.Service, error) {
	svc := &corev1.Service{}
	switch t := obj.(type) {
	case *corev1.Service:
		svc = t
	case *api.Service:
		if err := k8s_api_v1.Convert_core_Service_To_v1_Service(t, svc, nil); err != nil {
			return nil, err
		}