TestCloseable c1 = closer.register(TestCloseable.normal());
    TestCloseable c2 = closer.register(TestCloseable.normal());
    TestCloseable c3 = closer.register(TestCloseable.normal());

    assertFalse(c1.isClosed());
    assertFalse(c2.isClosed());
    assertFalse(c3.isClosed());

    closer.close();

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());
    assertTrue(c3.isClosed());

        Comparable c2 = newComparable(v2);
        assertEquals(0, c1.compareTo(c2), "expected " + v1 + " == " + v2);
        assertEquals(0, c2.compareTo(c1), "expected " + v2 + " == " + v1);
        assertEquals(c1.hashCode(), c2.hashCode(), "expected same hashcode for " + v1 + " and " + v2);
        assertEquals(c1, c2, "expected " + v1 + ".equals( " + v2 + " )");
        assertEquals(c2, c1, "expected " + v2 + ".equals( " + v1 + " )");

    TestCloseable c1 = closer.register(TestCloseable.normal());
    TestCloseable c2 = closer.register(TestCloseable.normal());
    TestCloseable c3 = closer.register(TestCloseable.normal());

    assertFalse(c1.isClosed());
    assertFalse(c2.isClosed());
    assertFalse(c3.isClosed());

    closer.close();

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());
    assertTrue(c3.isClosed());

      while (i + 4 <= utf16Length) {
        char c0 = input.charAt(i);
        char c1 = input.charAt(i + 1);
        char c2 = input.charAt(i + 2);
        char c3 = input.charAt(i + 3);
        if (c0 < 0x80 && c1 < 0x80 && c2 < 0x80 && c3 < 0x80) {
          int k1 = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24);
          k1 = mixK1(k1);
          h1 = mixH1(h1, k1);
          i += 4;
          len += 4;
        } else {

     *
     * @param c1 first signature to compare
     * @param c2 second signature to compare
     * @return MORE_SPECIFIC if c1 is more specific than c2, LESS_SPECIFIC if
     *         c1 is less specific than c2, INCOMPARABLE if they are incomparable.
     */
    private static int moreSpecific(Class<?>[] c1, Class<?>[] c2) {
        boolean c1MoreSpecific = false;
        boolean c2MoreSpecific = false;

    Function<Float, Boolean> c2 = Functions.compose(h, Functions.compose(g, f));

    // Might be nice (eventually) to have:
    //     assertEquals(c1, c2);

    // But for now, settle for this:
    assertEquals(c1.hashCode(), c2.hashCode());

    assertEquals(c1.apply(1.0f), c2.apply(1.0f));
    assertEquals(c1.apply(5.0f), c2.apply(5.0f));
  }

    CharSource c1 = CharSource.wrap("abc");
    CharSource c2 = CharSource.wrap("");
    CharSource c3 = CharSource.wrap("de");

    String expected = "abcde";

    assertThat(CharSource.concat(ImmutableList.of(c1, c2, c3)).read()).isEqualTo(expected);
    assertThat(CharSource.concat(c1, c2, c3).read()).isEqualTo(expected);
    assertThat(CharSource.concat(ImmutableList.of(c1, c2, c3).iterator()).read())
        .isEqualTo(expected);

      .isEqualTo(URI("http://host/a%C2%80b"))
    assertThat("http://host/a\u009fb".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/a%C2%9Fb"))
    // Percent-encoded in the query.
    assertThat("http://host/?a\u0000b".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/?a%00b"))
    assertThat("http://host/?a\u0080b".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/?a%C2%80b"))

        char c2 = seq.charAt(index);
        if (Character.isLowSurrogate(c2)) {
          return Character.toCodePoint(c1, c2);
        }
        throw new IllegalArgumentException(
            "Expected low surrogate but got char '"
                + c2
                + "' with value "
                + (int) c2
                + " at index "
                + index

        SmbTreeConnection c2 = newConn();
        SmbTreeImpl shared = mock(SmbTreeImpl.class);
        when(shared.acquire(false)).thenReturn(shared);

        setTree(c1, shared);
        setTree(c2, shared);
        assertTrue(c1.isSame(c2));

        SmbTreeImpl other = mock(SmbTreeImpl.class);
        when(other.acquire(false)).thenReturn(other);
        setTree(c2, other);
        assertFalse(c1.isSame(c2));