@Override
      public boolean tryAdvance(Consumer<? super T> action) {
        return delegate.tryAdvance((IntConsumer) i -> action.accept(function.apply(i)));
      }

      @Override
      public void forEachRemaining(Consumer<? super T> action) {
        delegate.forEachRemaining((IntConsumer) i -> action.accept(function.apply(i)));
      }

      @Override
      public @Nullable Spliterator<T> trySplit() {

        for (final Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
            writer.accept("Thread: " + entry.getKey());
            final StackTraceElement[] trace = entry.getValue();
            for (final StackTraceElement element : trace) {
                writer.accept("\tat " + element);
            }
        }
    }

    internal var noTransform: Boolean = false
    internal var immutable: Boolean = false

    /** Don't accept an unvalidated cached response. */
    fun noCache() = commonNoCache()

    /** Don't store the server's response in any cache. */
    fun noStore() = commonNoStore()

    /**
     * Only accept the response if it is in the cache. If the response isn't cached, a `504

		for {
			conn, err := ln.Accept()
			select {
			case listener.acceptCh <- acceptResult{conn, err, idx}:
			case <-listener.ctxDoneCh:
				return
			}
		}
	}

	// Start separate goroutine for each listener to handle connection.
	for idx, ln := range listener.listeners {
		go handleListener(idx, ln)
	}
}

     * An interface for consuming search results.
     */
    interface SearchConsumer {
        /**
         * Accepts a list of search results.
         *
         * @param t The list of search results.
         * @throws NamingException If a naming exception occurs.
         */
        void accept(List<SearchResult> t) throws NamingException;
    }

    /**
     * Gets the directory context.
     *

    val empty = CompressionInterceptor()
    val client =
      clientTestRule
        .newClientBuilder()
        .addInterceptor(empty)
        .addInterceptor { chain ->
          assertThat(chain.request().header("Accept-Encoding")).isNull()
          Response
            .Builder()
            .request(chain.request())
            .protocol(Protocol.HTTP_1_1)
            .code(200)
            .message("OK")

    }

    @Override public SocketAddress getLocalSocketAddress() {
      return endpoint;
    }

    @Override public Socket accept() throws IOException {
      try {
        UnixSocketChannel channel = serverSocketChannel.accept();
        return new TunnelingUnixSocket(path, channel, endpoint);
      } catch (ClosedChannelException e) {
        SocketException exception = new SocketException();

            }
            if (false == line.startsWith(leadingSpaces)) {
                log.accept(lines.lastLineNumber, "snippet line should start with [" + leadingSpaces + "]");
                continue;
            }
            int width = line.length() - leadingSpaces.length();
            if (width > max) {
                log.accept(lines.lastLineNumber, "snippet line should be no more than [" + max + "] characters but was [" + width + "]");

    [
        "array",
        ["string", "null"],
        None,
    ],
)
def test_allowed_schema_type(
    type_value: SchemaType | list[SchemaType] | None,
) -> None:
    """Test that Schema accepts SchemaType, List[SchemaType] and None for type field."""
    schema = Schema(type=type_value)
    assert schema.type == type_value


def test_invalid_type_value() -> None:

      @Override
      public boolean tryAdvance(Consumer<? super T> action) {
        return delegate.tryAdvance((IntConsumer) i -> action.accept(function.apply(i)));
      }

      @Override
      public void forEachRemaining(Consumer<? super T> action) {
        delegate.forEachRemaining((IntConsumer) i -> action.accept(function.apply(i)));
      }

      @Override
      public @Nullable Spliterator<T> trySplit() {