if (!baseDir.exists()) {
            return 0;
        }
        try {
            final FilePurgeVisitor visitor = new FilePurgeVisitor(baseDir.toPath(), imageExtention, expiry);
            Files.walkFileTree(baseDir.toPath(), visitor);
            return visitor.getCount();
        } catch (final Exception e) {
            throw new JobProcessingException(e);
        }
    }

    /**

import okhttp3.internal.publicsuffix.ResourcePublicSuffixList.Companion.PUBLIC_SUFFIX_RESOURCE
import okhttp3.internal.toCanonicalHost
import okhttp3.okHttpRoot
import okio.Buffer
import okio.FileSystem
import okio.Path.Companion.toPath
import org.junit.Before
import org.junit.Test
import org.junit.runner.RunWith

@RunWith(PublicSuffixTestRunner::class)
class PublicSuffixDatabaseTest {
  private val publicSuffixDatabase = PublicSuffixDatabase.get()

                // Copy tempFile to the actual file
                try {
                    java.nio.file.Files.copy(tempFile.toPath(), new File(file.getPath()).toPath(),
                            java.nio.file.StandardCopyOption.REPLACE_EXISTING);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }

        }
    }

    @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();

                if (!outputFile.exists()) {
                    outputFile.createNewFile();
                }
                // Write some dummy content to simulate actual thumbnail
                Files.write(outputFile.toPath(), ("thumbnail-" + thumbnailId).getBytes());
                return true;
            } catch (IOException e) {
                return false;
            }
        }

        @Override

      assertThat(file.getName()).contains("FileBackedOutputStream");
      if (!isAndroid() && !isWindows()) {
        PosixFileAttributes attributes =
            java.nio.file.Files.getFileAttributeView(file.toPath(), PosixFileAttributeView.class)
                .readAttributes();
        assertThat(attributes.permissions()).containsExactly(OWNER_READ, OWNER_WRITE);
      }
    }
    out.close();

        validateApi(body, messages -> {});
        return asStream("badword.csv").contentTypeOctetStream().stream(out -> {
            final Path tempFile = ComponentUtil.getSystemHelper().createTempFile("fess-badword-", ".csv").toPath();
            try {
                try (Writer writer = new BufferedWriter(new OutputStreamWriter(Files.newOutputStream(tempFile), getCsvEncoding()))) {
                    badWordService.exportCsv(writer);

        } finally {
            if (!isInMemory() && !done) {
                final File file = super.getFile();
                if (file != null) {
                    try {
                        Files.deleteIfExists(file.toPath());
                    } catch (final IOException e) {
                        logger.warning(e.getLocalizedMessage());
                    }
                }
            }
        }
    }

    public static void deleteInBackground(final File file) {
        if (file != null) {
            TimeoutManager.getInstance().addTimeoutTarget(() -> {
                try {
                    Files.deleteIfExists(file.toPath());
                } catch (final IOException e) {
                    throw new IORuntimeException(e);
                }
            }, 0, false);
        }
    }

        this.data = null;
        this.file = file;
    }

    @Override
    public void close() throws IOException {
        if (file != null) {
            Files.delete(file.toPath());
        }
    }

    /**
     * Returns an InputStream to read the content from the cache.
     * If the content is stored in a file, a FileInputStream is returned.