```go
// hashes the key returning an integer.
func sipHashMod(key string, cardinality int, id [16]byte) int {
        if cardinality <= 0 {
                return -1
        }
        sip := siphash.New(id[:])
        sip.Write([]byte(key))
        return int(sip.Sum64() % uint64(cardinality))
}
```

  }

  @Retention(RetentionPolicy.RUNTIME)
  @Keep
  private @interface Tested {}

  private abstract static class A {
    @Tested private boolean privateField;
    @Tested int packagePrivateField;
    @Tested protected int protectedField;
    @Tested public String publicField;
    @Tested private static Iterable<String> staticField;
    @Tested private final Object finalField;
    private volatile char volatileField;

import java.util.ArrayList;
import java.util.List;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.jspecify.annotations.NullMarked;

/**
 * Unit test for {@link LinkedHashMultiset}.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullMarked
public class LinkedHashMultisetTest extends TestCase {

  @J2ktIncompatible
  @GwtIncompatible // suite

  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

    private final ExecutorService executor = newSingleThreadExecutor();

    FakeService() {
      tearDownStack.addTearDown(this);
    }

    volatile int startupCalled = 0;
    volatile int shutdownCalled = 0;
    volatile int runCalled = 0;

    @Override
    protected void startUp() throws Exception {
      assertEquals(0, startupCalled);
      assertEquals(0, runCalled);

        // Find all element positions
        int modelVersionIndex = xmlOutput.indexOf("<modelVersion>");
        int groupIdIndex = xmlOutput.indexOf("<groupId>");
        int nameIndex = xmlOutput.indexOf("<name>");
        int descriptionIndex = xmlOutput.indexOf("<description>");
        int urlIndex = xmlOutput.indexOf("<url>");
        int licensesIndex = xmlOutput.indexOf("<licenses>");
        int propertiesIndex = xmlOutput.indexOf("<properties>");

          readUtf8()
        }

      fileSystem.write(metadataFile) {
        writeUtf8(corruptor(contents))
      }
    }
  }

  private fun testCorruptingCache(corruptor: () -> Unit): Response {
    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.enqueue(
      MockResponse(
        headers =
          headersOf(
            "Last-Modified",

            .resolveType(t));
  }

  public <T> void testWhere_primitiveArrayMapping() {
    Type t = new TypeCapture<T>() {}.capture();
    assertEquals(
        int.class,
        new TypeResolver().where(new TypeCapture<T[]>() {}.capture(), int[].class).resolveType(t));
  }

  public <T> void testWhere_parameterizedTypeMapping() {
    Type t = new TypeCapture<T>() {}.capture();
    assertEquals(

    verifyTableSize(17, 15, 32);
  }

  @GwtIncompatible // RegularImmutableSet.table not in emulation
  private void verifyTableSize(int inputSize, int setSize, int tableSize) {
    Builder<Integer> builder = ImmutableSet.builder();
    for (int i = 0; i < inputSize; i++) {
      builder.add(i % setSize);
    }
    ImmutableSet<Integer> set = builder.build();
    assertTrue(set instanceof RegularImmutableSet);

   * should always pass.
   */
  private static class ValidTestObject {
    private final int aspect1;
    private final int aspect2;

    ValidTestObject(int aspect1, int aspect2) {
      this.aspect1 = aspect1;
      this.aspect2 = aspect2;
    }

    @Override
    public boolean equals(@Nullable Object o) {