assertEquals("METADATA", SsoResponseType.METADATA.toString());
        assertEquals("LOGOUT", SsoResponseType.LOGOUT.toString());
    }

    public void test_equals() {
        // Test equals method for enum constants
        assertTrue(SsoResponseType.METADATA.equals(SsoResponseType.METADATA));
        assertTrue(SsoResponseType.LOGOUT.equals(SsoResponseType.LOGOUT));

  public void testOfInstance_equals() {
    new EqualsTester()
        .addEqualityGroup(Suppliers.ofInstance("foo"), Suppliers.ofInstance("foo"))
        .addEqualityGroup(Suppliers.ofInstance("bar"))
        .testEquals();
  }

  public void testCompose_equals() {
    new EqualsTester()
        .addEqualityGroup(
            Suppliers.compose(Functions.constant(1), Suppliers.ofInstance("foo")),

      new EqualsTester()
          .addEqualityGroup(cache.asMap().keySet(), keys)
          .addEqualityGroup(ImmutableSet.of())
          .testEquals();
      assertEquals(WARMUP_SIZE, keys.size());
      for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) {
        Object key = warmed.get(i - WARMUP_MIN).getKey();
        assertTrue(keys.contains(key));

        assertEquals(item1.hashCode(), item3.hashCode());

        // Different input should have different hashCode
        assertNotSame(item1.hashCode(), item4.hashCode());
    }

    public void test_equals() {
        // Test equals method
        StopwordsItem item1 = new StopwordsItem(1, "test");
        StopwordsItem item2 = new StopwordsItem(1, "test");
        StopwordsItem item3 = new StopwordsItem(2, "test");

    assertThrows(IllegalArgumentException.class, () -> ContiguousSet.closed(2L, 1L));
    assertThrows(IllegalArgumentException.class, () -> ContiguousSet.closedOpen(2L, 1L));
  }

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(
            ContiguousSet.create(Range.closed(1, 3), integers()),
            ContiguousSet.closed(1, 3),

              }
            });
  }

  public void testEquals() {
    SortedMap<Integer, String> map1 = ImmutableSortedMap.of(1, "one");
    SortedMap<Integer, String> map2 = ImmutableSortedMap.of(2, "two");
    new EqualsTester()
        .addEqualityGroup(map1, wrap(map1), wrap(map1))
        .addEqualityGroup(map2, wrap(map2))
        .testEquals();
  }

            ImmutableMultiset.of("a", "a", "b"))
        .addEqualityGroup(ImmutableMultiset.of("a", "b"))
        .addEqualityGroup(ImmutableMultiset.of("a", "b", "c", "d"))
        .testEquals();
  }

  public void testIterationOrder() {
    Collection<String> c = ImmutableMultiset.of("a", "b", "a");
    assertThat(c).containsExactly("a", "a", "b").inOrder();

    assertEquals("null=1", entry(NK, 1).toString());
    assertEquals("foo=null", entry("foo", NV).toString());
    assertEquals("null=null", entry(NK, NV).toString());
  }

  public void testEquals() {
    Entry<String, Integer> foo1 = entry("foo", 1);
    // Explicitly call `equals`; `assertEquals` might return fast
    assertTrue(foo1.equals(foo1));
    assertEquals(control("foo", 1), foo1);

  public void testGetCharset_unsupportedCharset() {
    MediaType mediaType = MediaType.parse("text/plain; charset=utf-wtf");
    assertThrows(UnsupportedCharsetException.class, mediaType::charset);
  }

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(
            MediaType.create("text", "plain"),
            MediaType.create("TEXT", "PLAIN"),
            MediaType.parse("text/plain"),

    new NullPointerTester()
        .testAllPublicInstanceMethods(
            EnumBiMap.create(ImmutableMap.of(Currency.DOLLAR, Country.CHILE)));
  }

  public void testEquals() {
    new EqualsTester()
        .addEqualityGroup(
            EnumBiMap.create(ImmutableMap.of(Currency.DOLLAR, Country.CANADA)),
            EnumBiMap.create(ImmutableMap.of(Currency.DOLLAR, Country.CANADA)))