name: Hosts
      type: string
    - description: Whether the service is external to the mesh or part of the mesh
        (MESH_EXTERNAL or MESH_INTERNAL)
      jsonPath: .spec.location
      name: Location
      type: string
    - description: Service resolution mode for the hosts (NONE, STATIC, or DNS)
      jsonPath: .spec.resolution
      name: Resolution
      type: string

							<sources>
								<source>
									<location>${project.build.directory}/tomcat-lib</location>
								</source>
							</sources>
						</mapping>
						<mapping>
							<directory>${packaging.fess.lib.dir}/classes/org/codelibs/fess</directory>
							<sources>
								<source>
									<location>${project.build.directory}/fess/WEB-INF/classes/org/codelibs/fess</location>
									<includes>

        subprojectA.linkedResources[0].location == normaliseFileSeparators(projectBsrcSiblingFolder.getAbsolutePath())
        subprojectA.linkedResources[0].locationUri == null

        subprojectA.linkedResources[1].name == 'src-root'
        subprojectA.linkedResources[1].type == '2'
        subprojectA.linkedResources[1].location == normaliseFileSeparators(srcRootFolder1.getAbsolutePath())

            withProblem("$location: external process started")
        }

        where:
        snippetsFactory                      | location
        exec("getProject()").java            | "Unknown location" // TODO(mlopatkin): Fix location there
        javaexec("getProject()").java        | "Unknown location"
        exec("getExecOperations()").java     | "Unknown location"

            plugins { }
            rootProject.name = "foo"
            plugins { }
            """.trimIndent()
        )

        assertEquals(2, result.size)
        assertEquals(listOf(2, 4), result.map { it.location.sourceData.lineRange.first })
        assertTrue(result.all { it.reason == DocumentCheckFailureReason.DuplicatePluginsBlock })
    }

    @Test
    fun `reports all duplicate pluginManagement blocks`() {

 */

package org.gradle.internal.extensions.core

import org.gradle.groovy.scripts.ScriptSource
import java.net.URI


/**
 * Same as `resource.location.uri`.
 */
val ScriptSource.uri: URI?

    }

    private File getJavaHome(File location) {
        if (OperatingSystem.current().isMacOsX()) {
            if (new File(location, MAC_OS_JAVA_HOME_FOLDER).exists()) {
                return new File(location, MAC_OS_JAVA_HOME_FOLDER);
            }

            File[] subfolders = location.listFiles(File::isDirectory);
            if (subfolders != null) {

            summary.problemCount,
            equalTo(3)
        )
    }

    private
    fun buildLogicProblem(location: String, message: String) = PropertyProblem(
        PropertyTrace.BuildLogic(Describables.of(location), 1),
        StructuredMessage.build { text(message) }
    )

        then:
        failure.assertOutputContains("Hello")
        problems.assertFailureHasProblems(failure) {
            withProblem("${location.replace('/', File.separator)}: external process started")
        }

        where:
        snippetsFactory             | file                           | location
        exec().groovy               | "build.gradle"                 | "Build file 'build.gradle': line 5"

 * The name argument is a specifier that is relative to the url argument.
 * This method always returns immediately, whether or not the image exists. 
 *
 * @param url an absolute URL giving the base location of the image
 * @param name the location of the image, relative to the url argument
 * @return the image at the specified URL
 * @see Image
 */
public Image getImage(URL url, String name) {
   try {