assertFalse(entry("foo", 1).equals(control("bar", 1)));
    assertFalse(entry("foo", 1).equals(new Object()));
    assertFalse(entry("foo", 1).equals(null));
  }

  public void testEqualsNull() {
    assertEquals(control(NE, 1), entry(NE, 1));
    assertFalse(control(NE, 1).equals(entry(NE, 2)));
    assertFalse(entry(NE, 1).equals(control("bar", 1)));

                  SetMultimap<String, Integer> filter(SetMultimap<String, Integer> multimap) {
                    multimap.put("foo", 17);
                    multimap.put("bar", 32);
                    multimap.put("foo", 16);
                    return filterKeys(multimap, not(Predicates.in(ImmutableSet.of("foo", "bar"))));
                  }
                })
            .named("Multimaps.filterKeys[SetMultimap, Predicate]")

text=foo...

    // stored log records causes a ConcurrentModificationException
    assertTrue(handler.getStoredLogRecords().isEmpty());
    ExampleClassUnderTest.foo();
    ExampleClassUnderTest.foo();
    for (LogRecord unused : handler.getStoredLogRecords()) {
      ExampleClassUnderTest.foo();
    }
  }

  @Override
  public final void runBare() throws Throwable {
    try {
      setUp();
      runTest();
    } finally {

    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));
    assertEquals("[foo x 2, bar]", multiset.toString());
  }

  public void testCreateFromIterable() {
    Multiset<String> multiset = TreeMultiset.create(asList("foo", "bar", "foo"));
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));

@GwtCompatible
@NullMarked
public class RegularImmutableTableTest extends AbstractImmutableTableTest {
  private static final ImmutableSet<Cell<Character, Integer, String>> CELLS =
      ImmutableSet.of(
          immutableCell('a', 1, "foo"), immutableCell('b', 1, "bar"), immutableCell('a', 2, "baz"));

  private static final ImmutableSet<Character> ROW_SPACE = ImmutableSet.of('a', 'b');

  public void testPut() {
    assertThrows(UnsupportedOperationException.class, () -> table.put("foo", 1, 'a'));
    assertSize(0);
  }

  @Override
  public void testPutAllTable() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    Table<String, Integer, Character> other = HashBasedTable.create();
    other.put("foo", 1, 'd');
    other.put("bar", 2, 'e');
    other.put("cat", 2, 'f');

                  SetMultimap<String, Integer> filter(SetMultimap<String, Integer> multimap) {
                    multimap.put("foo", 17);
                    multimap.put("bar", 32);
                    multimap.put("foo", 16);
                    return filterKeys(multimap, not(Predicates.in(ImmutableSet.of("foo", "bar"))));
                  }
                })
            .named("Multimaps.filterKeys[SetMultimap, Predicate]")

        .build(),
    )

    val url = server.url("/same")

    // First QUERY request with body "foo"
    val request1 =
      Request
        .Builder()
        .url(url)
        .query("foo".toRequestBody())
        .cacheUrlOverride(url.newBuilder().addQueryParameter("body", "foo").build())
        .build()
    val response1 = client.newCall(request1).execute()

        fooAuth.setServer("foo");
        fooAuth.setPort(1000);
        smbAuthenticationHolder.add(fooAuth);

        assertEquals(hogeAuth, smbAuthenticationHolder.get("smb://hoge/"));
        assertEquals(fugaAuth, smbAuthenticationHolder.get("smb://fuga/"));
        assertEquals(fooAuth, smbAuthenticationHolder.get("smb://foo:1000/"));