public void testAllOverloads_checkArgument() throws Exception {
    for (ImmutableList<Class<?>> sig : allSignatures(boolean.class)) {
      Method checkArgumentMethod =
          Preconditions.class.getMethod("checkArgument", sig.toArray(new Class<?>[] {}));
      checkArgumentMethod.invoke(null /* static method */, getParametersForSignature(true, sig));

      Object[] failingParams = getParametersForSignature(false, sig);

   * consistent. For example, this method <i>might</i> choose to pass through recognized
   * implementations of {@code PeekingIterator} when the behavior of the implementation is known to
   * meet the contract guaranteed by this method.
   *
   * <p>There is no {@link Iterable} equivalent to this method, so use this method to wrap each
   * individual iterator as it is generated.
   *

   * }
   *
   * <p><b>Note:</b> This method <i>may</i> work with certain non-ASCII text but is not safe for use
   * with arbitrary Unicode text. It is mostly intended for use with text that is known to be safe
   * for use with it (such as all-ASCII text) and for simple debugging text. When using this method,
   * consider the following:
   *
   * <ul>
   *   <li>it may split surrogate pairs

    }

    /**
     * Configures the {@link ToStringHelper} so {@link #toString()} will ignore properties with null
     * value. The order of calling this method, relative to the {@code add()}/{@code addValue()}
     * methods, is not significant.
     *
     * @since 18.0 (since 12.0 as {@code Objects.ToStringHelper.omitNullValues()}).
     */
    @CanIgnoreReturnValue

        Method method = getSuperclassMethod(response.getClass(), "getNumEntries");
        method.setAccessible(true);
        return (int) method.invoke(response);
    }

    private void setNumEntries(NetShareEnumResponse response, int value) throws Exception {
        Method method = getSuperclassMethod(response.getClass(), "setNumEntries", int.class);
        method.setAccessible(true);

   * connected - this does nothing and returns false. Otherwise, this returns true and the caller
   * should immediately invoke this method again until it returns false.
   *
   * This method may only be invoked by the writer thread. There may be only thread invoking this
   * method at a time.
   */
  @Throws(IOException::class)
  internal fun writeOneFrame(): Boolean {
    val writer: WebSocketWriter?

    }

    @Test
    @DisplayName("Test FileBasicInfo size method")
    void testFileBasicInfoSize() {
        // Given
        FileBasicInfo info = new FileBasicInfo();

        // When & Then
        assertEquals(40, info.size());
    }

    @Test
    @DisplayName("Test FileBasicInfo toString method")
    void testFileBasicInfoToString() {
        // Given
        FileBasicInfo info =

        return new StreamOf<>(() -> map != null ? map.entrySet().stream() : Collections.<K, V> emptyMap().entrySet().stream());
    }

    /**
     * A wrapper class for a {@link Stream} that provides utility methods.
     *
     * @param <T> the type of elements in the stream
     */
    public static class StreamOf<T> {

        private final Supplier<Stream<T>> supplier;

        /**

   * serialize the copy. Other methods similar to this do not implement serialization at all for
   * this reason.
   *
   * <p><b>Java 8+ users:</b> many use cases for this method are better addressed by {@link
   * java.util.stream.Stream#map}. This method is not being deprecated, but we gently encourage you
   * to migrate to streams.
   */

import com.google.common.annotations.J2ktIncompatible;
import java.util.Arrays;
import java.util.Map;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * Methods factored out so that they can be emulated differently in GWT.
 *
 * @author Hayward Chan
 */
@GwtCompatible
final class Platform {
  /** Returns the platform preferred implementation of a map based on a hash table. */