if err != nil {
			t.Fatalf("Test %d: failed to encrypt stream: %v", i, err)
		}
		data, err := io.ReadAll(ciphertext)
		if err != nil {
			t.Fatalf("Test %d: failed to encrypt stream: %v", i, err)
		}

		plaintext, err := Decrypt(KMS, bytes.NewReader(data), test.Context)
		if err != nil {
			t.Fatalf("Test %d: failed to decrypt stream: %v", i, err)
		}
		data, err = io.ReadAll(plaintext)
		if err != nil {

            ProfileActivationContext context,
            ModelProblemCollector problems) {
        return getActiveProfiles(profiles.stream().map(Profile::new).collect(Collectors.toList()), context, problems)
                .stream()
                .map(Profile::getDelegate)
                .collect(Collectors.toList());
    }

        verifyTokenKeep(() -> downloadpage(form.dictId));
        return synonymService.getSynonymFile(form.dictId)
                .map(file -> asStream(new File(file.getPath()).getName()).contentTypeOctetStream().stream(out -> {
                    file.writeOut(out);
                })).orElseGet(() -> {
                    throwValidationError(messages -> messages.addErrorsFailedToDownloadSynonymFile(GLOBAL),

        boolean hasNoSuccess =
                sortedProjects.stream().noneMatch(project -> result.getBuildSummary(project) instanceof BuildSuccess);

        if (hasNoSuccess) {
            return Optional.empty();
        }

        List<String> remainingProjects = sortedProjects.stream()
                .filter(project -> result.getBuildSummary(project) == null

     * @return output stream, needs to be closed when finished
     * @throws CIFSException
     */
    OutputStream openOutputStream ( boolean append ) throws CIFSException;


    /**
     * Opens an output stream writing to the file (truncating, write only, sharable)
     * 
     * @return output stream, needs to be closed when finished
     * @throws CIFSException
     */

        return designJspFileNameMap.entrySet().stream().map(e -> new Pair<>(e.getKey(), e.getValue())).toArray(n -> new Pair[n]);
    }

    public List<Path> refreshDesignJspFiles() {
        final List<Path> fileList = new ArrayList<>();
        stream(ComponentUtil.getVirtualHostHelper().getVirtualHostPaths())
                .of(stream -> stream.filter(s -> s != null && !"/".equals(s)).forEach(key -> {

import javax.xml.transform.OutputKeys
import javax.xml.transform.Transformer
import javax.xml.transform.TransformerFactory
import javax.xml.transform.dom.DOMSource
import javax.xml.transform.stream.StreamResult
import org.w3c.dom.Document
import org.w3c.dom.Element
import org.w3c.dom.Node

class XIncludeAwareXmlProvider {

    Document root

    Element parse(File sourceFile) {

  @J2ktIncompatible
  private void writeObject(ObjectOutputStream stream) throws IOException {
    stream.defaultWriteObject();
    stream.writeInt(keySet().size());
    for (K key : keySet()) {
      stream.writeObject(key);
    }
    stream.writeInt(size());
    for (Entry<K, V> entry : entries()) {
      stream.writeObject(entry.getKey());
      stream.writeObject(entry.getValue());
    }
  }

            final PutObjectArgs args = PutObjectArgs.builder().bucket(fessConfig.getStorageBucket()).object(objectName)
                    .stream(in, uploadFile.getFileSize(), -1).contentType("application/octet-stream").build();
            minioClient.putObject(args);
        } catch (final Exception e) {
            throw new StorageException("Failed to upload " + objectName, e);
        }
    }

        stream(crawlingConfig.getPermissions()).of(stream -> stream.forEach(p -> roleTypeList.add(p)));
        putResultDataBody(dataMap, fessConfig.getIndexFieldRole(), roleTypeList);
        // virtualHosts
        putResultDataBody(dataMap, fessConfig.getIndexFieldVirtualHost(),
                stream(crawlingConfig.getVirtualHosts()).get(stream -> stream.filter(StringUtil::isNotBlank).collect(Collectors.toList())));