return getPath("WEB-INF/", "classes", names);
    }

    /**
     * Gets the path to original files directory.
     *
     * @param names the path components to append to the orig directory
     * @return the Path object pointing to the original files directory
     */
    public static Path getOrigPath(final String... names) {
        return getPath("WEB-INF/", "orig", names);
    }

        assertEquals("\\test\\directory", request.getPath());

        // Test single backslash
        request.setPath("\\");
        assertEquals("\\", request.getPath());

        // Test empty path
        request.setPath("");
        assertEquals("\\", request.getPath());
    }

    @Test
    @DisplayName("Test getPath returns correct formatted path")
    void testGetPath() {

            when(mockFile.getPath()).thenReturn("/share/dir/");
            RecordingFilter filter = new RecordingFilter();
            filter.accept(mockFile);
            // Verify the filter stored the reference
            // assertSame may not be necessary but demonstrates captured file
            // we simply check that getPath was called
            verify(mockFile, times(1)).getPath();
        }
    }

        // Stub the getPath method to return a specific value
        when(mockDir.getPath()).thenReturn("/share/folder/");

        // Implementation uses dir.getPath() to check if file should be in that path
        SmbFilenameFilter filter = (dir, name) -> {
            if (dir == null)
                return false;
            String path = dir.getPath();

    void testGetPath() {
        // Given
        String path = "/test/path";
        when(mockReferralData.getPath()).thenReturn(path);

        // When
        String result = mockReferralData.getPath();

        // Then
        assertEquals(path, result);
        verify(mockReferralData).getPath();
    }

    @Test
    @DisplayName("Should get expiration")
    void testGetExpiration() {

    return "alice", required_scopes.scopes


def get_data():
    return [1, 2, 3]


def get_data_override():
    return [3, 4, 5]


@app.get("/user")
def read_user(
    user_data: tuple[str, list[str]] = Security(get_user, scopes=["foo", "bar"]),
    data: list[int] = Depends(get_data),
):
    return {"user": user_data[0], "scopes": user_data[1], "data": data}

        AccessResultDataImpl<?> accessResultData = new AccessResultDataImpl<>();
        accessResultData.setData(xml.getBytes("UTF-8"));
        accessResultData.setEncoding("UTF-8");

        Map<String, Object> dataMap = XmlUtil.getDataMap(accessResultData);
        assertNotNull(dataMap);

                    throw new DictionaryException("Failed to update " + dictFile.getPath());
                }
            } catch (final IOException e) {
                throw new DictionaryException("Failed to update " + dictFile.getPath(), e);
            }

        }).orElse(() -> {
            throw new DictionaryException(dictFile.getPath() + " does not exist.");
        });
    }

    /**

        final PathInfo pi = convertToItem(id);
        if (StringUtil.isEmpty(pi.getPath()) && StringUtil.isEmpty(pi.getName())) {
            return StringUtil.EMPTY;
        }
        if (StringUtil.isEmpty(pi.getPath())) {
            return pi.getName();
        }
        return pi.getPath() + "/" + pi.getName();
    }

    /**

            this.basedir = null;
        } else {
            try {
                URL url = new URL(repository.getUrl());
                if ("file".equals(url.getProtocol())) {
                    basedir = new File(url.getPath());
                }
            } catch (MalformedURLException e) {
                throw new IllegalStateException(e);
            }
        }
    }

    @Override
    public void close() {}