@Override
    public DefaultModelBuildingRequest setPomPath(Path pomPath) {
        this.pomPath = (pomPath != null) ? pomPath.toAbsolutePath() : null;
        return this;
    }

    @Override
    public synchronized ModelSource getModelSource() {
        if (modelSource == null && pomPath != null) {
            modelSource = new FileModelSource(pomPath);
        }
        return modelSource;
    }

            it.descendant "Download ${server.uri}${projectB.pomPath}"
            it.descendant "Download ${server.uri}/repo/group/projectC/maven-metadata.xml"
            it.descendant "Download ${server.uri}${projectC.pomPath}"
            it.descendant "Download ${server.uri}${projectD.metaDataPath}"
            it.descendant "Download ${server.uri}${projectD.pomPath}"
        }

        def downloadBMetadata = events.operation("Download ${server.uri}${projectB.pomPath}")
        def downloadBArtifact = events.operation("Download ${server.uri}${projectB.artifactPath}")
        def downloadCRootMetadata = events.operation("Download ${server.uri}/repo/group/projectC/maven-metadata.xml")
        def downloadCPom = events.operation("Download ${server.uri}${projectC.pomPath}")

     * {@link FileModelSource} instead.
     *
     * @param pomPath The POM file of the project to build the effective model for, may be {@code null} to build the
     *            model of some POM from the repository.
     * @return This request, never {@code null}.
     * @since 4.0.0
     */
    ModelBuildingRequest setPomPath(Path pomPath);

    /**
     * Gets the level of validation to perform on processed models.

            this.artifact = ArtifactUtils.copyArtifact(artifact);
            if ("pom".equals(artifact.getType()) && file != null) {
                pomHash = file.getPath().hashCode() + file.lastModified();
            } else {
                pomHash = 0;
            }
            this.resolveManagedVersions = resolveManagedVersions;
            this.repositories.add(localRepository);

	comPath := filepath.Join(t.TempDir(), "example.com")
	batPath := comPath + ".bat"
	installBat(t, batPath)

	cmd := exec.Command(comPath)
	out, err := cmd.CombinedOutput()
	t.Logf("%v: %v\n%s", cmd, err, out)
	if !errors.Is(err, fs.ErrNotExist) {
		t.Errorf("Command(%#q).Run: %v\nwant fs.ErrNotExist", comPath, err)
	}

	resolved, err := exec.LookPath(comPath)

		t.Errorf("Got unexpected path: %s, expected %s", globalPath, expectedGlobalPath)
	}
	expectedPodPath := filepath.Join(tmpDir, testPodPath)
	podPath, volName := mapper.GetPodDeviceMapPath()
	if podPath != expectedPodPath {
		t.Errorf("Got unexpected pod path: %s, expected %s", podPath, expectedPodPath)
	}
	if volName != testPVName {
		t.Errorf("Got unexpected volNamne: %s, expected %s", volName, testPVName)
	}

	}

	clientConfig := restclient.AnonymousClientConfig(bootstrapClientConfig)
	pemPath := store.CurrentPath()
	clientConfig.KeyFile = pemPath
	clientConfig.CertFile = pemPath
	if err := writeKubeconfigFromBootstrapping(clientConfig, kubeconfigPath, pemPath); err != nil {
		return nil, nil, err
	}

		t.Run(rt.name, func(t2 *testing.T) {
			if len(rt.pemContent) > 0 {
				pemPath := filepath.Join(tmpdir, "kubelet.pem")
				err := os.WriteFile(pemPath, rt.pemContent, 0644)
				if err != nil {
					t.Errorf("Couldn't create pem file: %v", err)
					return
				}
				rt.kubeconfigContent = []byte(strings.Replace(string(rt.kubeconfigContent), "kubelet.pem", pemPath, -1))
			}

			return "", fmt.Errorf("failed to retrieve Pod %s/%s: %v", podNamespace, podName, err)
		}

		promPath, promPort, err := util.PrometheusPathAndPort(pod)
		if err != nil {
			return "", fmt.Errorf("failed to retrieve prometheus path and port from Pod %s/%s: %v", podNamespace, podName, err)
		}
		path = promPath
		port = promPort
	}