output.append(dep.getGroup() + ":" + dep.getName() + "," + dep.getVersion() + "," + url + "," + licenseType + "\n");
        }

        Files.write(outputFile.toPath(), output.toString().getBytes("UTF-8"), StandardOpenOption.CREATE);
    }

    @Input
    public LinkedHashMap<String, String> getMappings() {
        return mappings;
    }

    @Override
    public Metadata read(File input, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(input, "input cannot be null");

        return read(Files.newInputStream(input.toPath()), options);
    }

    @Override
    public Metadata read(Reader input, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(input, "input cannot be null");

        try (Reader in = input) {

            public void store(org.codelibs.fess.dict.DictionaryFile<?> file, File tempFile) {
                // Copy tempFile to testFile
                try {
                    java.nio.file.Files.copy(tempFile.toPath(), testFile.toPath(), java.nio.file.StandardCopyOption.REPLACE_EXISTING);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        };

    }

    private static boolean isExecutableFile(File file) {
        try {
            Set<PosixFilePermission> permissions = Files.getFileAttributeView(file.toPath(), PosixFileAttributeView.class)
                .readAttributes()
                .permissions();
            return permissions.contains(PosixFilePermission.OTHERS_EXECUTE)

                .getFile()
                .getExists()
                .contains(BASE_DIR));
    }

    private static Model readPom(File file) throws Exception {
        try (InputStream is = Files.newInputStream(file.toPath())) {
            return new MavenStaxReader().read(is);
        }
    }

        }
    }

    @Test
    public void testFileBasedCacheClose() throws IOException {
        tempFile = File.createTempFile("test", ".tmp", Curl.tmpDir);
        Files.write(tempFile.toPath(), "Hello, World!".getBytes());
        assertTrue(tempFile.exists());

        ContentCache cache = new ContentCache(tempFile);

        // Close should delete the file
        cache.close();

        try (FileWriter output = new FileWriter(outputFile)) {
            output.write(
                generateFile(QualifiedVersion.of(VersionProperties.getElasticsearch()), Files.readString(templateFile.toPath()), entries)
            );
        }
    }

    @VisibleForTesting
    static String generateFile(QualifiedVersion version, String template, List<ChangelogEntry> entries) throws IOException {

import okhttp3.Dns
import okhttp3.EventRecorder
import okhttp3.OkHttpClient
import okhttp3.Protocol
import okhttp3.testing.PlatformRule
import okio.Buffer
import okio.ByteString.Companion.decodeHex
import okio.Path.Companion.toPath
import okio.fakefilesystem.FakeFileSystem
import org.junit.jupiter.api.Assertions.fail
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test

                    Files.copy(stream, checkstyleConf.toPath(), StandardCopyOption.REPLACE_EXISTING);
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
                try (InputStream stream = checkstyleSuppressionsUrl.openStream()) {
                    Files.copy(stream, checkstyleSuppressions.toPath(), StandardCopyOption.REPLACE_EXISTING);

            try {
                if (classpathElement.isDirectory()) {
                    walkJavaFiles(classpathElement.toPath(), ".class", addClassPackage);
                } else if (classpathElement.getName().endsWith(".jar")) {
                    try (FileSystem jar = FileSystems.newFileSystem(classpathElement.toPath(), Map.of())) {
                        for (Path root : jar.getRootDirectories()) {