@Override
  final UnmodifiableIterator<Cell<R, C, V>> cellIterator() {
    throw new AssertionError("should never be called");
  }

  @Override
  final Spliterator<Cell<R, C, V>> cellSpliterator() {
    throw new AssertionError("should never be called");
  }

  @Override
  public ImmutableCollection<V> values() {
    return (ImmutableCollection<V>) super.values();
  }

                        ),
                    ),
            ),
            Stage(
                StageName.HISTORICAL_PERFORMANCE,
                trigger = if (branch.isLegacyRelease) Trigger.NEVER else Trigger.WEEKLY,
                runsIndependent = true,
                performanceTests =
                    listOf(
                        PerformanceTestCoverage(
                            4,

        // Verify that the response is not modified for a successful authentication
        verify(mockResponse, never()).setHeader(anyString(), anyString());
        verify(mockResponse, never()).setStatus(any(int.class));
    }

    /**
     * Test case for the instance method doAuthentication.
     * It should just delegate to the static authenticate method.

 * the License.
 */
package com.google.common.collect;

import java.util.Collection;
import org.jspecify.annotations.Nullable;

/** Never actually created; instead delegates to JdkBackedImmutableMultiset. */
final class RegularImmutableMultiset<E> extends ImmutableMultiset<E> {
  static final ImmutableMultiset<Object> EMPTY =

   * is not guaranteed to return zero when the dataset consists of the same value multiple times,
   * due to numerical errors. However, it is guaranteed never to return a negative result.
   *
   * <h3>Non-finite values</h3>
   *
   * <p>If the dataset contains any non-finite values ({@link Double#POSITIVE_INFINITY}, {@link

 * limitations under the License.
 */

package com.google.common.collect.testing;

import com.google.common.annotations.GwtCompatible;

/**
 * A type which will never be used as the element type of any collection in our tests, and so can be
 * used to test how a Collection behaves when given input of the wrong type.
 */
@GwtCompatible
public enum WrongType {
  VALUE

        when(mockBufferCache.getBuffer()).thenReturn(expectedBuffer);

        // When
        byte[] buffer = mockBufferCache.getBuffer();

        // 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() {

abstract class AggregateFutureState<OutputT extends @Nullable Object>
    extends AbstractFuture.TrustedFuture<OutputT> {
  /*
   * The following fields are package-private, even though we intend never to use them outside this
   * file. For discussion, see AbstractFutureState.
   */

  // Lazily initialized the first time we see an exception; not released until all the input futures

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.net.MalformedURLException;
import java.net.URL;

import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * ImmutableSet implementation backed by a JDK HashSet, used to defend against apparent hash
 * flooding. This implementation is never used on the GWT client side.
 *
 * @author Louis Wasserman
 */
@GwtIncompatible
final class JdkBackedImmutableSet<E> extends IndexedImmutableSet<E> {
  private final Set<?> delegate;