package com.google.common.cache;

import com.google.caliper.AfterExperiment;
import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import com.google.common.primitives.Ints;
import java.util.Random;
import java.util.concurrent.atomic.AtomicLong;
import org.jspecify.annotations.NullUnmarked;

/**
 * Single-threaded benchmark for {@link LoadingCache}.
 *
 * @author Charles Fry
 */

    Random random = new Random();

    int sizeRemaining = size;

    // TODO(kevinb): generate better test contents for multisets
    while (sizeRemaining > 0) {
      // The JVM will return interned values for small ints.
      Integer value = random.nextInt(1000) + 128;
      int count = min(random.nextInt(10) + 1, sizeRemaining);
      sizeRemaining -= count;
      hashMultiset.add(value, count);
      linkedHashMultiset.add(value, count);

            assertEquals(EncryptionNegotiateContext.CIPHER_AES128_GCM, SMBUtil.readInt2(buffer, offset + 2));
        }

        @ParameterizedTest
        @ValueSource(ints = { 1, 3, 5, 10, 20 })
        @DisplayName("Should encode various cipher counts correctly")
        void testEncodeVariousCipherCounts(int cipherCount) {
            int[] ciphers = new int[cipherCount];

 * </ul>
 *
 * <p>This class uses (possibly repeated) invocations of {@link java.lang.System#gc()} to cause
 * finalization to happen. However, a call to {@code System.gc()} is specified to be no more than a
 * hint, so this technique may fail at the whim of the JDK implementation, for example if a user
 * specified the JVM flag {@code -XX:+DisableExplicitGC}. But in practice, it works very well for
 * ordinary tests.
 *

package com.google.common.collect;

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import com.google.common.base.Optional;
import com.google.common.primitives.Ints;
import java.util.List;
import java.util.Random;
import org.jspecify.annotations.NullUnmarked;

/**
 * Benchmarks for the {@code TreeTraverser} operations on binary trees.
 *
 * @author Louis Wasserman
 */

import com.google.common.collect.Iterators;
import com.google.common.collect.Sets;
import com.google.common.collect.UnmodifiableIterator;
import com.google.common.math.IntMath;
import com.google.common.primitives.Ints;
import java.util.AbstractSet;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * This class provides a skeletal implementation of {@link BaseGraph}.
 *

 * the License.
 */

package com.google.common.primitives;

import jsinterop.annotations.JsMethod;
import jsinterop.annotations.JsPackage;

/** Web specializations for {@link Ints} methods. */
public abstract class IntsMethodsForWeb {

  @JsMethod(name = "Math.min", namespace = JsPackage.GLOBAL)
  public static native int min(int... array);

            assertEquals(1310720, response.getTotalBytesWritten());
        }

        @ParameterizedTest
        @DisplayName("Should decode various chunksWritten values")
        @ValueSource(ints = { 0, 1, 10, 100, 1000, Integer.MAX_VALUE })
        void testDecodeVariousChunksWritten(int chunks) throws SMBProtocolDecodingException {
            byte[] buffer = createValidCopyChunkResponse(chunks, 0, 0);

    BloomFilter<byte[]> bf = BloomFilter.create(Funnels.byteArrayFunnel(), 100);
    for (int i = 0; i < 10; i++) {
      bf.put(Ints.toByteArray(i));
    }

    BloomFilter<byte[]> copy = SerializableTester.reserialize(bf);
    for (int i = 0; i < 10; i++) {
      assertTrue(copy.mightContain(Ints.toByteArray(i)));
    }
    assertThat(copy.expectedFpp()).isEqualTo(bf.expectedFpp());

    for (int i = 0; i < len; i++) {
      doubles[i] = longs[i];
    }
    return doubles;
  }

  private static double[] intsToDoubles(int[] ints) {
    int len = ints.length;
    double[] doubles = new double[len];
    for (int i = 0; i < len; i++) {
      doubles[i] = ints[i];
    }
    return doubles;
  }

  /**
   * Performs an in-place selection to find the element which would appear at a given index in a