@Param Topology topology;

  @Param({"1", "100", "10000", "1000000"})
  int size;

  @Param Traversal traversal;

  @Param({"1234"})
  SpecialRandom rng;

  @BeforeExperiment
  void setUp() {
    this.view = traversal.view(topology.createTree(size, rng).get(), VIEWER);
  }

  @Benchmark
  int traversal(int reps) {
    int tmp = 0;

    for (int i = 0; i < reps; i++) {

import org.jspecify.annotations.Nullable;

/** Replacements for JUnit's {@code assertThrows} that work under GWT/J2CL. */
@GwtCompatible
@NullMarked
final class ReflectionFreeAssertThrows {
  interface ThrowingRunnable {
    void run() throws Throwable;
  }

  interface ThrowingSupplier {
    @Nullable Object get() throws Throwable;
  }

  @CanIgnoreReturnValue
  static <T extends Throwable> T assertThrows(

     * </p>
     *
     * @param zipFile
     *            Zip file. Must not be {@literal null}.
     */
    public static void close(final ZipFile zipFile) {
        assertArgumentNotNull("zipFile", zipFile);

        try {
            zipFile.close();
        } catch (final IOException e) {

        // }

        this.memoryRegister = new Object(); // Placeholder

        log.debug("DiSNI memory region registered, size: {}", buffer.remaining());
    }

    @Override
    public void invalidate() {
        if (valid && memoryRegister != null) {
            try {
                // In real implementation, this would deregister the memory:
                // memoryRegister.deregisterMemory();

    public StandardDescendingMap() {}

    @Override
    NavigableMap<K, V> forward() {
      return ForwardingNavigableMap.this;
    }

    @Override
    public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
      forward().replaceAll(function);
    }

    @Override
    protected Iterator<Entry<K, V>> entryIterator() {

  private final long[][] longsToAdd = new long[ARRAY_SIZE][2];
  private final long[][] longsToMul = new long[ARRAY_SIZE][2];

  @Param({"APACHE", "GUAVA"})
  Impl impl;

  @BeforeExperiment
  void setUp() {
    for (int i = 0; i < ARRAY_SIZE; i++) {
      factorials[i] = RANDOM_SOURCE.nextInt(200);
      for (int j = 0; j < 2; j++) {
        nonnegInt[i][j] = randomNonNegativeBigInteger(Integer.SIZE - 2).intValue();

        index = (index + 1) & mask;
      }
      // Check to see if we wrapped around the whole table.
    } while (index != startingIndex);
    return false;
  }

  @Override
  void setBits(BitSet table) {
    if (containsZero) {
      table.set(0);
    }
    for (char c : this.table) {
      if (c != 0) {
        table.set(c);
      }
    }
  }

import org.jspecify.annotations.Nullable;

/** Replacements for JUnit's {@code assertThrows} that work under GWT/J2CL. */
@GwtCompatible
@NullMarked
final class ReflectionFreeAssertThrows {
  interface ThrowingRunnable {
    void run() throws Throwable;
  }

  interface ThrowingSupplier {
    @Nullable Object get() throws Throwable;
  }

  @CanIgnoreReturnValue
  static <T extends Throwable> T assertThrows(

import junit.framework.TestCase;
import org.jspecify.annotations.NullMarked;

/** Tests for {@code Hashing}. */
@GwtCompatible
@NullMarked
public class HashingTest extends TestCase {
  public void testSmear() {
    assertEquals(1459320713, smear(754102528));
    assertEquals(-160560296, smear(1234567890));
    assertEquals(-1017931171, smear(1));
    assertEquals(-1350072884, smear(-2000000000));

import org.jspecify.annotations.Nullable;

/** Replacements for JUnit's {@code assertThrows} that work under GWT/J2CL. */
@GwtCompatible
@NullMarked
final class ReflectionFreeAssertThrows {
  interface ThrowingRunnable {
    void run() throws Throwable;
  }

  interface ThrowingSupplier {
    @Nullable Object get() throws Throwable;
  }

  @CanIgnoreReturnValue
  static <T extends Throwable> T assertThrows(