* @param stream the {@link Consumer} to process the {@link Stream}
         */
        public void of(final Consumer<Stream<T>> stream) {
            try (Stream<T> s = supplier.get()) {
                stream.accept(s);
            }
        }

        /**
         * Applies the given function to a stream created by the supplier and returns the result.
         * The stream is automatically closed after the function is applied.

   *       Objects.equal}{@code (a, b)} implies that {@code predicate.apply(a) ==
   *       predicate.apply(b))}.
   * </ul>
   *
   * @throws NullPointerException if {@code input} is null and this predicate does not accept null
   *     arguments
   */
  boolean apply(@ParametricNullness T input);

  /**
   * Indicates whether another object is equal to this predicate.
   *

        // Then
        assertNotNull(buffer, "getBuffer should never return null");
        assertSame(expectedBuffer, buffer, "Should return configured buffer");
    }

    @Test
    @DisplayName("releaseBuffer should accept byte arrays gracefully")
    void testReleaseBufferContract() {
        // Given
        byte[] buffer = new byte[1024];
        doNothing().when(mockBufferCache).releaseBuffer(buffer);

        // When & Then

// Or create a visible subclass for testing.
// For now, let's assume we can modify the original class slightly for testability,
// or we accept the less precise testToStringFormat test.

// Let's add a package-private helper to TransTransactNamedPipeResponse:
// String superToString() { return super.toString(); }
// And modify the test to use it.

 * always very useful information.
 *
 * <p>On the other hand, a <i>parameter</i> type of {@link ImmutableList} is generally a nuisance to
 * callers. Instead, accept {@link Iterable} and have your method or constructor body pass it to the
 * appropriate {@code copyOf} method itself.
 *
 * <p>Expressing the immutability guarantee directly in the type that user code references is a

     * 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.
     *

	Requests chan<- []byte

	muxID uint64
	ctx   context.Context
}

// Send a payload to the remote server.
func (s *Stream) Send(b []byte) error {
	if s.Requests == nil {
		return errors.New("stream does not accept requests")
	}
	select {
	case s.Requests <- b:
		return nil
	case <-s.ctx.Done():
		return context.Cause(s.ctx)
	}
}

// Results returns the results from the remote server one by one.

     *
     * @param visitor the visitor to call back, must not be {@code null}
     * @return {@code true} to visit siblings nodes of this node as well, {@code false} to skip siblings
     */
    boolean accept(@Nonnull NodeVisitor visitor);

    /**
     * Returns a new tree starting at this node, filtering the children.
     * Note that this node will not be filtered and only the children
     * and its descendant will be checked.

        try {
            final XPathFactory factory = XPathFactory.newInstance();
            builder.accept(factory);
            return factory.newXPath();
        } catch (final Exception e) {
            throw new CrawlerSystemException("Failed to create XPath instance.", e);
        }
    }

    /**
     *  Use an XPath string to select a nodelist.

        // Current behavior of test impl: returns same reference
        assertSame(raw, t.toByteArray(), "should return the same reference as mechanismToken");
    }

    @Test
    @DisplayName("Setters accept null and getters return null")
    void settersAcceptNull() {
        TestSpnegoToken t = new TestSpnegoToken();
        t.setMechanismToken(null);
        t.setMechanismListMIC(null);