assertTrue(c.isInterface(), "SpnegoConstants must be an interface");
        assertEquals(4, c.getDeclaredFields().length, "Unexpected number of fields");
        assertEquals(0, c.getDeclaredMethods().length, "No declared methods expected");
        assertEquals(0, c.getDeclaredConstructors().length, "Interfaces have no constructors");
    }

    @Test
    @DisplayName("Fields are public static final Strings with expected values")

import static java.lang.Math.max;

import com.google.common.annotations.GwtCompatible;
import com.google.common.primitives.Ints;
import org.jspecify.annotations.Nullable;

/**
 * Static methods for implementing hash-based collections.
 *
 * @author Kevin Bourrillion
 * @author Jesse Wilson
 * @author Austin Appleby
 */
@GwtCompatible
final class Hashing {
  private Hashing() {}

  /*

import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import java.math.RoundingMode;
import org.jspecify.annotations.NullUnmarked;

/**
 * Benchmarks for the rounding methods of {@code LongMath}.
 *
 * @author Louis Wasserman
 */
@NullUnmarked
public class LongMathRoundingBenchmark {
  @Param({"DOWN", "UP", "FLOOR", "CEILING", "HALF_EVEN", "HALF_UP", "HALF_DOWN"})
  RoundingMode mode;

 * </p>
 *
 * clientConnectionManager the HttpClientConnectionManager used to manage connections
 * idleConnectionTimeout the timeout duration (in milliseconds) for idle connections
 *
 * <p>Methods:</p>
 * <ul>
 *   <li>{@link #expired()}: Handles the expiration of connections by closing expired and idle connections.</li>
 * </ul>
 *
 * <p>Logging:</p>
 * <ul>

    }
  }

  /**
   * Implements {@code Multimap.put()} -- and no other methods -- for a {@code Map} by ignoring all
   * but the latest value for each key. This class exists only so that we can use {@link
   * MultimapsCollectionTest#populateMultimapForGet(Multimap, String[])} and similar methods to
   * populate a map to be passed to {@link Multimaps#forMap(Map)}. All tests should run against the

import com.google.caliper.Param;
import java.util.ArrayList;
import java.util.LinkedList;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests the speed of iteration of different iteration methods for collections.
 *
 * @author David Richter
 */
@NullUnmarked
public class IteratorBenchmark {
  @Param({"0", "1", "16", "256", "4096", "65536"})
  int size;

        Metadata source2 =
                new Metadata(new MetadataStaxReader().read(new ByteArrayInputStream(baos.toByteArray()), true));
        assertNotNull(source2);
    }

    /*-- START helper methods to populate metadata objects ---*/
    private static final String SNAPSHOT = "SNAPSHOT";

    private static final String DEFAULT_SNAPSHOT_TIMESTAMP_FORMAT = "yyyyMMdd.HHmmss";

            authProperty = "Proxy-Authorization";
        }
        String authorization = null;
        final List methods = (List) getHeaderFields0().get(authHeader);
        if (methods == null) {
            return null;
        }
        final Iterator iterator = methods.iterator();
        while (iterator.hasNext()) {
            final String currentAuthMethod = (String) iterator.next();

   * @param executor the executor in which the listeners callback methods will be run.
   */
  public void addListener(Listener listener, Executor executor) {
    state.addListener(listener, executor);
  }

  /**
   * Initiates service {@linkplain Service#startAsync startup} on all the services being managed. It
   * is only valid to call this method if all of the services are {@linkplain State#NEW new}.
   *

 * </ul>
 *
 * <p>Because of this situation, any public method accepting an iterable should invoke the {@code
 * iterator} method only once, and should be tested using this class. Exceptions to this rule should
 * be clearly documented.
 *
 * <p>Note that although your APIs should be liberal in what they accept, your methods which
 * <i>return</i> iterables should make every attempt to return ones of the robust variety.