assertThat(child.delete()).isTrue();

      if (!isAndroid() && !isWindows()) {
        PosixFileAttributes attributes =
            java.nio.file.Files.getFileAttributeView(temp.toPath(), PosixFileAttributeView.class)
                .readAttributes();
        assertThat(attributes.permissions())
            .containsExactly(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE);
      }
    } finally {

    }

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

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

                }

                @Nonnull
                @Override
                public Optional<Path> getPomFile() {
                    return Optional.ofNullable(res.getPomFile()).map(File::toPath);
                }

                @Nonnull
                @Override
                public Optional<Project> getProject() {
                    return Optional.ofNullable(session.getProject(res.getProject()));

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

                .version("1.0-SNAPSHOT")
                .build());
        Mockito.when(context.getRawModel(pomFile, root.resolve("pom.xml"))).thenReturn(parent);
        Mockito.when(context.locate(root)).thenReturn(root.resolve("pom.xml"));
        Model initial = new Model(org.apache.maven.api.model.Model.newBuilder()
                .parent(org.apache.maven.api.model.Parent.newBuilder()

        final File[] jarFiles = ResourceUtil.getPluginJarFiles(PluginHelper.ArtifactType.DATA_STORE.getId());
        for (final File jarFile : jarFiles) {
            try (FileSystem fs = FileSystems.newFileSystem(jarFile.toPath(), ClassLoader.getSystemClassLoader())) {
                final Path xmlPath = fs.getPath("fess_ds++.xml");
                try (InputStream is = Files.newInputStream(xmlPath)) {

			var podName, ns string
			if labelSelector != "" {
				pl, err := kubeClient.PodsForSelector(context.TODO(), ctx.NamespaceOrDefault(ctx.Namespace()), labelSelector)
				if err != nil {
					return fmt.Errorf("not able to locate pod with selector %s: %v", labelSelector, err)
				}

				if len(pl.Items) < 1 {
					return errors.New("no pods found")
				}

				if len(pl.Items) > 1 {

        Path pomPath = model.getPomPath();
        if (pomPath != null) {
            buffer.append(" (").append(pomPath).append(')');
        }

        return buffer.toString();
    }

    static String toPath(Model model) {
        String path = "";

        if (model != null) {
            Path pomPath = model.getPomPath();

            if (pomPath != null) {
                path = pomPath.toAbsolutePath().toString();

        }
    }

    private org.apache.maven.api.services.Source toSource(File file, Source source) {
        if (file != null && file.exists()) {
            return org.apache.maven.api.services.Source.fromPath(file.toPath());
        } else if (source instanceof FileSource fs) {
            return org.apache.maven.api.services.Source.fromPath(fs.getPath());
        } else if (source != null) {