}

    @Override
    public String findTool(String toolName) {
        Path toRet = findTool(toolName, Paths.get(getJavaHome()).normalize());
        if (toRet != null) {
            return toRet.toAbsolutePath().toString();
        }
        return null;
    }

    private static Path findTool(String toolName, Path installDir) {
        Path bin = installDir.resolve("bin"); // NOI18N
        if (Files.isDirectory(bin)) {

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.cling.invoker.mvnup.goals;

import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Map;
import java.util.Optional;

import eu.maveniverse.domtrip.Document;
import eu.maveniverse.domtrip.Editor;
import eu.maveniverse.domtrip.Element;

    }

    /**
     * Validate and normalize a path
     *
     * @param path the path to validate
     * @return normalized safe path
     * @throws SmbException if path is invalid or dangerous
     */
    public String validatePath(String path) throws SmbException {
        if (path == null || path.isEmpty()) {
            throw new SmbException("Path cannot be null or empty");
        }

        // Check length

    p: Annotated[QueryModelOptionalListStr, Query()],
):
    return {"p": p.p}


@pytest.mark.parametrize(
    "path",
    ["/optional-list-str", "/model-optional-list-str"],
)
def test_optional_list_str_schema(path: str):
    assert app.openapi()["paths"][path]["get"]["parameters"] == [
        {
            "required": False,
            "schema": {
                "anyOf": [

async def read_model_required_str(p: Annotated[QueryModelRequiredStr, Query()]):
    return {"p": p.p}


@pytest.mark.parametrize(
    "path",
    ["/required-str", "/model-required-str"],
)
def test_required_str_schema(path: str):
    assert app.openapi()["paths"][path]["get"]["parameters"] == [
        {
            "required": True,
            "schema": {"title": "P", "type": "string"},
            "name": "p",

def read_model_required_list_str(p: Annotated[HeaderModelRequiredListStr, Header()]):
    return {"p": p.p}


@pytest.mark.parametrize(
    "path",
    ["/required-list-str", "/model-required-list-str"],
)
def test_required_list_str_schema(path: str):
    assert app.openapi()["paths"][path]["get"]["parameters"] == [
        {
            "required": True,
            "schema": {
                "title": "P",

            Document moduleBDoc = Document.of(moduleBPomXml);

            Map<Path, Document> pomMap = new HashMap<>();
            pomMap.put(Paths.get("project", "pom.xml"), parentDoc);
            pomMap.put(Paths.get("project", "module-a", "pom.xml"), moduleADoc);
            pomMap.put(Paths.get("project", "module-b", "pom.xml"), moduleBDoc);

            Editor editor = new Editor(moduleBDoc);

        List<Path> paths = session.resolveDependencies(coords);

        assertNotNull(paths);
        assertEquals(10, paths.size());
        assertEquals("test-extension-1.jar", paths.get(0).getFileName().toString());

        // JUnit has an "Automatic-Module-Name", so it appears on the module path.
        Map<PathType, List<Path>> dispatched = session.resolveDependencies(

    }

    /**
     * Test isPathSafe with path outside base directory
     *
     * @throws Exception
     */
    @Test
    public void testIsPathSafe_PathOutsideBase() throws Exception {
        final Path baseDir = tempFolder.getRoot().toPath();
        final Path outsidePath = Paths.get("/tmp/outside.txt");

	if err != nil {
		return err
	}
	defer done(0, &err)

	return p.storage.DeleteBulk(ctx, volume, paths...)
}

func (p *xlStorageDiskIDCheck) Delete(ctx context.Context, volume string, path string, deleteOpts DeleteOptions) (err error) {
	ctx, done, err := p.TrackDiskHealth(ctx, storageMetricDelete, volume, path)
	if err != nil {
		return err
	}