.listFiles()
        ?.associateWith { dir ->
            val dirPath = dir.toPath()
            Files.walk(dirPath).use { paths ->
                paths.filter { !it.toFile().isDirectory }
                    .limit(4)
                    .map { dirPath.relativize(it).toString() }
                    .collect(Collectors.toList())
            }
        }?.filter {

            assertTrue(Files.exists(nestedPath));
            assertTrue(Files.isDirectory(nestedPath));
        } finally {
            // Cleanup
            deleteDirectory(tempDir.toFile());
        }
    }

    @Test
    public void test_createDirectories_existingPath() throws Exception {
        // Test that Files.createDirectories is idempotent (no exception on existing dir)

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);

        // Create temp directory for testing
        tempDir = Files.createTempDirectory("thumbnail_test").toFile();
        tempDir.deleteOnExit();

        // Create a test thumbnail manager with minimal initialization
        thumbnailManager = new TestThumbnailManager();
        thumbnailManager.baseDir = tempDir;

    fun File.withUniqueDirectory(prefixPath: String): File =
        Files.createTempDirectory(
            withDirectory(prefixPath.substringBeforeLast("/")).toPath(),
            prefixPath.substringAfterLast("/")
        ).toFile()

    private
    fun File.withDirectory(path: String): File =
        resolve(path).apply {
            mkdirs()
        }

    private

     */
    public static File[] getPluginJarFiles(final FilenameFilter filter) {
        final File libDir = getPluginPath().toFile();
        if (!libDir.exists()) {
            return new File[0];
        }
        return libDir.listFiles(filter);
    }

    /**
     * Resolves system properties in a given string.

            if (normalizedPath.contains("..")) {
                throw new IllegalArgumentException("Invalid file path: path=" + path);
            }
            final File file = filePath.toFile();
            final String canonicalPath = file.getCanonicalPath();
            final String[] allowedPathProperties = { "fess.var.path", "fess.webapp.path", "fess.conf.path" };
            boolean isAllowed = false;

    }

    private
    fun minify(artifact: File, keepClasses: Set<String>, jarFile: File): File {
        val tempDirectory = java.nio.file.Files.createTempDirectory(jarFile.name).toFile()
        val classesDir = tempDirectory.resolve("classes")
        val manifestFile = tempDirectory.resolve("MANIFEST.MF")
        val buildReceiptFile = tempDirectory.resolve("build-receipt.properties")

            // Read and verify file content
            List<String> lines = new ArrayList<>();
            try (BufferedReader reader =
                    new BufferedReader(new InputStreamReader(new FileInputStream(tempFile.toFile()), Constants.CHARSET_UTF_8))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    lines.add(line);
                }
            }

            if (varPath != null) {
                baseDir = new File(varPath, THUMBNAILS_DIR_NAME);
            } else {
                baseDir = ResourceUtil.getThumbnailPath().toFile();
            }
        }
        if (baseDir.mkdirs()) {
            logger.info("Created thumbnail directory: {}", baseDir.getAbsolutePath());
        }
        if (!baseDir.isDirectory()) {

            Files.createDirectories(nestedPath);

            assertTrue(Files.exists(nestedPath));
            assertTrue(Files.isDirectory(nestedPath));
        } finally {
            deleteDirectory(tempDir.toFile());
        }
    }

    @Test
    public void test_atomicCreateDirectories_existingDirectory() throws Exception {
        // Test that Files.createDirectories doesn't fail on existing directory