private void writeObject(ObjectOutputStream stream) throws IOException {
      stream.defaultWriteObject();
      stream.writeObject(factory);
      stream.writeObject(backingMap());
    }

    @GwtIncompatible
    @J2ktIncompatible
        @SuppressWarnings("unchecked") // reading data stored by writeObject
    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {

        private void writeObject(ObjectOutputStream stream) throws IOException {
      stream.defaultWriteObject();
      stream.writeObject(factory);
      stream.writeObject(backingMap());
    }

    @GwtIncompatible
    @J2ktIncompatible
        @SuppressWarnings("unchecked") // reading data stored by writeObject
    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {

                }
                stream(accessToken.getPermissions()).of(stream -> stream.forEach(permissionSet::add));
                final String name = accessToken.getParameterName();
                stream(request.getParameterValues(name)).of(stream -> stream.filter(StringUtil::isNotBlank).forEach(permissionSet::add));
                return OptionalEntity.of(permissionSet);

                    }
                }
                stream(groups).of(stream -> stream.forEach(s -> permissionSet.add(systemHelper.getSearchRoleByGroup(s))));
                stream(roles).of(stream -> stream.forEach(s -> permissionSet.add(systemHelper.getSearchRoleByRole(s))));
                permissions = permissionSet.stream().filter(StringUtil::isNotBlank).distinct().toArray(n -> new String[n]);
            }

    sink.writeLines(ImmutableList.of("foo", "bar", "baz").stream());
    String separator = LINE_SEPARATOR.value();
    assertEquals("foo" + separator + "bar" + separator + "baz" + separator, sink.getString());
  }

  public void testWriteLines_stream_separator() throws IOException {
    sink.writeLines(ImmutableList.of("foo", "bar", "baz").stream(), "!");
    assertEquals("foo!bar!baz!", sink.getString());
  }

    /**
     * Reads the next ASN.1 object from a stream and casts it to the specified type
     * @param <T> the target ASN.1 primitive type
     * @param type the target class type
     * @param stream the ASN.1 input stream
     * @return next object from stream cast to type
     * @throws PACDecodingException if types are incompatible
     * @throws IOException if reading from stream fails
     */

        body.permissions = stream(entity.getPermissions()).get(stream -> stream.map(s -> permissionHelper.decode(s))
                .filter(StringUtil::isNotBlank)
                .distinct()
                .collect(Collectors.joining("\n")));
        body.virtualHosts = stream(entity.getVirtualHosts())

import com.google.common.collect.testing.SpliteratorTester;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Spliterator;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import junit.framework.TestCase;
import org.jspecify.annotations.NullMarked;

/** Tests for {@code CollectSpliterators}. */
@GwtCompatible
@NullMarked

import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Stream;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;

            final String[] oldLabels = DocumentUtil.getValue(dataMap, fessConfig.getIndexFieldLabel(), String[].class);
            StreamUtil.stream(oldLabels).of(stream -> stream.forEach(newLabelSet::add));
            matchedLabelSet.stream().forEach(newLabelSet::add);
            dataMap.put(fessConfig.getIndexFieldLabel(), newLabelSet.toArray(new String[newLabelSet.size()]));
        }