if (oldLabels != null) {
                    for (String label : oldLabels) {
                        newLabelSet.add(label);
                    }
                }
                matchedLabelSet.stream().forEach(newLabelSet::add);
                dataMap.put(fessConfig.getIndexFieldLabel(), newLabelSet.toArray(new String[newLabelSet.size()]));
            }

   * response was received without TLS.
   */
  @get:JvmName("handshake") val handshake: Handshake?,
  /** Returns the HTTP headers. */
  @get:JvmName("headers") val headers: Headers,
  /**
   * Returns a non-null stream with the server's response. The returned value must be
   * [closed][ResponseBody] and may be consumed only once.
   *
   * If this is a [cacheResponse], [networkResponse], or [priorResponse], the server's response body

            headerCount,
          )
          nextHeaderIndex += entriesToEvict
        }
        return entriesToEvict
      }

      /**
       * Read `byteCount` bytes of headers from the source stream. This implementation does not
       * propagate the never indexed flag of a header.
       */
      @Throws(IOException::class)
      fun readHeaders() {
        while (!source.exhausted()) {

            logger.debug("Initializing SmbClient...");
        }

        super.init();

        final Properties props = new Properties();
        System.getProperties().entrySet().stream().filter(e -> e.getKey().toString().startsWith("jcifs.")).forEach(e -> {
            props.setProperty((String) e.getKey(), (String) e.getValue());
        });
        try {

import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import org.jspecify.annotations.Nullable;

/**
 * A {@link Map} whose contents will never change, with many other important properties detailed at
 * {@link ImmutableCollection}.
 *

                // Verify expected shares are present
                List<String> shareList = List.of(shares);
                boolean hasPublic = shareList.stream().anyMatch(s -> s.toLowerCase().contains("public"));
                boolean hasShared = shareList.stream().anyMatch(s -> s.toLowerCase().contains("shared"));

                assertTrue(hasPublic || hasShared, "Should contain expected shares");

	// We can safely allow RenameFile errors up to len(er.getDisks()) - writeQuorum
	// otherwise return failure. Cleanup successful renames.
	return evalDisks(disks, errs), err
}

// PutObjectPart - reads incoming stream and internally erasure codes
// them. This call is similar to single put operation but it is part
// of the multipart transaction.
//
// Implements S3 compatible Upload Part API.

	}
	tmp := make([]byte, len(b))
	copy(tmp, b)
	h.block <- tmp
	return len(b), h.err
}

// CloseWithError will close the stream and return the specified error.
// This can be done several times, but only the first error will be sent.
// After calling this the stream should not be written to.
func (h *httpStreamResponse) CloseWithError(err error) {
	if h.done == nil {
		return
	}
	h.done <- err

        stopwordsFile.reload(null, is);

        assertEquals(2, stopwordsFile.stopwordsItemList.size());
        // The content creates two lines: "word\n1" and "word\"
        assertTrue(stopwordsFile.stopwordsItemList.stream().anyMatch(item -> item.getInput().contains("word")));
    }

    // Test StopwordsUpdater inner class
    public void test_updater_writeOldItem() {
        loadTestData();

 * under the License.
 */
package org.apache.maven.artifact.repository.metadata;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import javax.xml.stream.XMLStreamException;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;