);
    }

    private void writeFile(File file, String content) {
        try {
            Files.writeString(file.toPath(), content, CREATE, TRUNCATE_EXISTING);
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    private String execInCheckoutDir(Action<ExecSpec> execSpecConfig) {

            }
        }

        private String getPackageName(File file) throws IOException {
            try (Stream<String> lines = Files.lines(file.toPath())) {
                String packageLine = lines.filter(line -> line.startsWith("package"))
                    .findFirst()
                    .orElseThrow(() -> new IOException("Can't find package definition in file " + file));

                    public Object getValue(String expression) {
                        if (projectDir != null && "baseUri".equals(expression)) {
                            return projectDir.getAbsoluteFile().toPath().toUri().toASCIIString();
                        }
                        return null;
                    }
                },
                PROJECT_PREFIXES,
                false);

        final Path confPath = getConfPath(names);
        if (Files.exists(confPath)) {
            return confPath;
        }
        return org.codelibs.core.io.ResourceUtil.getResourceAsFile(String.join("/", names)).toPath();
    }

    /**
     * Gets the path to compiled classes directory.
     *
     * @param names the path components to append to the classes directory

        String content = "File-based content test";
        java.io.File tmpFile = java.io.File.createTempFile("response-test-", ".tmp");
        tmpFile.deleteOnExit();
        java.nio.file.Files.write(tmpFile.toPath(), content.getBytes(java.nio.charset.StandardCharsets.UTF_8));

        CurlResponse response = new CurlResponse();
        response.setEncoding("UTF-8");
        response.setContentCache(new ContentCache(tmpFile));

  private val windows = subject.windows

  @TempDir
  lateinit var cacheDirFile: File
  private val cacheDir: Path
    get() =
      when (baseFilesystem) {
        is FakeFileSystem -> "/cache".toPath()
        else -> cacheDirFile.path.toPath()
      }
  private val appVersion = 100
  private lateinit var journalFile: Path
  private lateinit var journalBkpFile: Path
  private val taskFaker = TaskFaker()

        }
    }

    private boolean fileContainsText(File referencedFile, String text) {
        try {
            for (String line : Files.readAllLines(referencedFile.toPath())) {
                if (line.contains(text)) {
                    return true;
                }
            }
        } catch (IOException e) {
            // ignore
        }
        return false;

        verifyToken(this::asDownloadHtml);

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

            } catch (MalformedURLException e) {
                throw new IllegalStateException(e);
            }
        } else {
            return Files.newInputStream(new File(pluginFile, descriptor).toPath());
        }
    }

    /**
     * Creates a shallow copy of this plugin descriptor.
     */
    @Override
    public PluginDescriptor clone() {
        try {

        public String getIdentifier() {
            return identifier;
        }

        public boolean matches(File licenseFile) {
            try {
                String content = Files.readString(licenseFile.toPath()).replaceAll("\\*", " ");
                return pattern.matcher(content).find();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }
    }