}
      } else {
        entry.currentEditor = null
        for (t in 0 until valueCount) {
          fileSystem.deleteIfExists(entry.cleanFiles[t])
          fileSystem.deleteIfExists(entry.dirtyFiles[t])
        }
        i.remove()
      }
    }
  }

  /**
   * Creates a new journal that omits redundant information. This replaces the current journal if it
   * exists.
   */

        String result;
        Path src = sourcePathProvider.get();
        if (src == null) {
            Files.deleteIfExists(target);
            result = null;
        } else if (!Files.exists(src)) {
            Files.deleteIfExists(target);
            result = "";
        } else {
            String current = sha1(src);
            String existing = sourceState.get();

          new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
                throws IOException {
              Files.deleteIfExists(file);
              return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc)
                throws IOException {

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

            Pac pac = pacData.getPac();
            PacLogonInfo li = pac.getLogonInfo();
            Assert.assertEquals("test1", li.getUserName());
        } finally {
            Files.deleteIfExists(p);
            Files.deleteIfExists(krbConfig);
        }
    }

    @Override
    public void removeResumptionData(MavenProject rootProject) {
        Path resumeProperties = Paths.get(rootProject.getBuild().getDirectory(), RESUME_PROPERTIES_FILENAME);
        try {
            Files.deleteIfExists(resumeProperties);
        } catch (IOException e) {
            LOGGER.warn("Could not delete {} file. ", RESUME_PROPERTIES_FILENAME, e);
        }
    }

                    Files.delete(f);
                } catch (final IOException e) {
                    logger.warn("Failed to delete {}", f, e);
                }
            });
            Files.deleteIfExists(dir);
        } catch (final IOException e) {
            logger.warn("Failed to delete {}", dir, e);
        }
    }

    protected Path getJarFile(final Artifact artifact) {

              Files.deleteIfExists(file);
              return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc)
                throws IOException {
              if (exc != null) {
                return FileVisitResult.TERMINATE;
              }
              Files.deleteIfExists(dir);

    }

    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);
        }
    }

      delete(file)
      return true
    } catch (_: IOException) {
    }
  }
  delete(file)
  return false
}

/** Delete file we expect but don't require to exist. */
internal fun FileSystem.deleteIfExists(path: Path) {
  try {
    delete(path)
  } catch (fnfe: FileNotFoundException) {
    return
  }
}

/** Tolerant delete, try to clear as many files as possible even after a failure. */