});
    }

    public void test_ofNull() {
        assertEquals(0, (int) StreamUtil.stream().get(s -> s.toArray().length));
        Object[] o = {};
        assertEquals(0, (int) StreamUtil.stream(o).get(s -> s.toArray().length));
        Map<Object, Object> map = new HashMap<Object, Object>();
        assertEquals(0, (int) StreamUtil.stream(map).get(s -> s.toArray().length));
    }

    public void test_ofMap() {

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

        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())
                .get(stream -> stream.filter(StringUtil::isNotBlank).distinct().map(String::trim).collect(Collectors.joining("\n")));

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.ds;

import static org.codelibs.core.stream.StreamUtil.stream;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

  }

  /** In-memory stream-based implementation of Hasher. */
  private final class BufferingHasher extends AbstractHasher {
    final ExposedByteArrayOutputStream stream;

    BufferingHasher(int expectedInputSize) {
      this.stream = new ExposedByteArrayOutputStream(expectedInputSize);
    }

    @Override
    public Hasher putByte(byte b) {
      stream.write(b);
      return this;
    }

        }
    }

    /**
     * Retrieve a stream of the project's artifacts.
     * Do not include the POM artifact as the file can't be set anyway.
     */
    private Stream<org.apache.maven.artifact.Artifact> getProjectArtifacts(MavenProject project) {
        return Stream.concat(Stream.of(project.getArtifact()), project.getAttachedArtifacts().stream());
    }

    connection.start(sendConnectionPreface = false)

    // verify the peer received the ACK
    val ackFrame = peer.takeFrame()
    assertThat(ackFrame.type).isEqualTo(Http2.TYPE_SETTINGS)
    assertThat(ackFrame.streamId).isEqualTo(0)
    assertThat(ackFrame.ack).isTrue()

    taskFaker.runTasks()

    return connection
  }

  private fun updateMaxConcurrentStreams(
    connection: Http2Connection,

            BeanUtil.copyBeanToBean(form, entity, op -> op.exclude(Stream
                    .concat(Stream.of(Constants.COMMON_CONVERSION_RULE), Stream.of(Constants.PERMISSIONS)).toArray(n -> new String[n])));
            final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
            entity.setPermissions(split(form.permissions, "\n").get(

      private set
    internal var throttlePeriodNanos: Long

    var socketPolicy: SocketPolicy

    internal var bodyDelayNanos: Long

    internal var headersDelayNanos: Long

    /** The streams the server will push with this response. */
    val pushPromises: MutableList<PushPromise>

    val settings: Settings

    constructor() {
      this.inTunnel = false

   */
  @GwtIncompatible // java.io.ObjectOutputStream
  private void writeObject(ObjectOutputStream stream) throws IOException {
    stream.defaultWriteObject();
    stream.writeObject(keyTypeOrObjectUnderJ2cl);
    stream.writeObject(valueTypeOrObjectUnderJ2cl);
    Serialization.writeMap(this, stream);
  }

  @SuppressWarnings("unchecked") // reading fields populated by writeObject