// that are known to the runtime.
//
// The first local is a bool called retValid with a whole pointer-word reserved
// for it on the stack. The purpose of this word is so that the runtime knows
// whether the stack-allocated return space contains valid values for stack
// scanning.
//
// The second local is an abi.RegArgs value whose offset is also known to the
// runtime, so that a stack map for it can be constructed, since it contains

    private CurrentGradleInstallationLocator() {
    }

    public synchronized static CurrentGradleInstallation locate() {
        return locateViaClassLoader(CurrentGradleInstallationLocator.class.getClassLoader());
    }

    private static CurrentGradleInstallation locateViaClassLoader(ClassLoader classLoader) {
        Class<?> clazz;

    # Must be set for any cluster configured with private docker registry.
    imagePullSecrets: []
    # - private-registry-key

    # Default resources allocated
    defaultResources:
      requests:
        cpu: 100m

        then:
        ManifestUtil.parseManifestClasspath(jarFile) == [new File(jarFile.parentFile, 'foo.jar').toURI()]
    }

    def "returned classpath URI is absolute and can be used to locate file"() {
        when:
        def classpathFile = tmpDir.createFile("mydir/foo.jar")
        createJar(manifestWithClasspath('foo.jar'))

        and:

        }

        @Override
        public Model getRawModel(Path from, Path p) {
            throw new UnsupportedOperationException();
        }

        @Override
        public Path locate(Path path) {
            throw new UnsupportedOperationException();
        }
    }

	}, `apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: external-service
spec:
{{- if .ManuallyAllocate }}
  addresses: [240.240.240.239] # Semi-random address for the range Istio allocates in
{{- end }}
  exportTo: [.]
  hosts:
  - {{.Hostname}}
  location: MESH_EXTERNAL
  resolution: DNS
  endpoints:
  - address: external.{{.Namespace}}.svc.cluster.local
  ports:

	}
	if _, ok := metadata[MetaContext]; ok {
		return nil, true
	}
	return nil, false
}

// CreateMultipartMetadata adds the multipart flag entry to metadata
// and returns modified metadata. It allocates a new metadata map if
// metadata is nil.
func CreateMultipartMetadata(metadata map[string]string) map[string]string {
	if metadata == nil {
		return map[string]string{MetaMultipart: ""}
	}

                spec.contextualLabel(message)
                    .withException(new TaskSelectionException(message));
            });
        }
        String message = String.format("Cannot locate %s that match '%s' as %s", context.getType(), context.getOriginalPath(),
            matcher.formatErrorMessage("task", searchContext));

        Path pomPath = pomFile.resolveSibling(relativePath).normalize();
        if (Files.isDirectory(pomPath)) {
            pomPath = context.locate(pomPath);
        }

        if (pomPath == null || !Files.isRegularFile(pomPath)) {
            return Optional.empty();
        }

    if (testDir != null) {
      return testDir;
    }

    URL testFileUrl = IoTestCase.class.getResource("testdata/i18n.txt");
    if (testFileUrl == null) {
      throw new RuntimeException("unable to locate testdata directory");
    }

    if (testFileUrl.getProtocol().equals("file")) {
      try {
        File testFile = new File(testFileUrl.toURI());
        testDir = testFile.getParentFile(); // the testdata directory