assertTrue(multimap.keySet() instanceof SortedSet);
    assertTrue(multimap.asMap() instanceof SortedMap);
  }

  // J2kt cannot translate the Comparable rawtype in a usable way (it becomes Comparable<Object>
  // but types are typically only Comparable to themselves).
  @SuppressWarnings({"rawtypes", "unchecked"})
  private static MultimapBuilderWithKeys<Comparable<?>> rawtypeToWildcard(

   * algorithms should document their behavior in the presence of duplicates.
   *
   * <p>The elements of the returned {@code Iterable} must each be:
   *
   * <ul>
   *   <li>Non-null
   *   <li>Usable as {@code Map} keys (see the Guava User Guide's section on <a
   *       href="https://github.com/google/guava/wiki/GraphsExplained#graph-elements-nodes-and-edges">
   *       graph elements</a> for details)
   * </ul>
   *

   * algorithms should document their behavior in the presence of duplicates.
   *
   * <p>The elements of the returned {@code Iterable} must each be:
   *
   * <ul>
   *   <li>Non-null
   *   <li>Usable as {@code Map} keys (see the Guava User Guide's section on <a
   *       href="https://github.com/google/guava/wiki/GraphsExplained#graph-elements-nodes-and-edges">
   *       graph elements</a> for details)
   * </ul>
   *

        SmbRenewableCredentials impl = new SelfRenewingCreds();

        // Assert: the extended interface relationship holds
        assertTrue(impl instanceof CredentialsInternal, "Should be usable as CredentialsInternal");

        // Cast and check we can call clone() from CredentialsInternal contract
        CredentialsInternal ci = (CredentialsInternal) impl;
        CredentialsInternal cloned = ci.clone();

            EncryptionNegotiateContext context = new EncryptionNegotiateContext();

            assertTrue(context instanceof NegotiateContextResponse);
        }

        @Test
        @DisplayName("Should be usable as both request and response")
        void testDualInterfaceUsage() {
            EncryptionNegotiateContext context = new EncryptionNegotiateContext();

            NegotiateContextRequest request = context;

    assertSame(STRING_LENGTH, set.comparator());
  }

  // TODO(b/172823566): Use mainline testToImmutableSortedSet once CollectorTester is usable.
  public void testToImmutableSortedSet_java7() {
    // Note that a Collector should generally enforce consistent comparator between builders
    ImmutableSortedSet.Builder<String> zis =

    SerializableTester.reserializeAndAssert(test.keySet());

    SerializableTester.reserializeAndAssert(nonEmptyRangeMap);
  }

  // TODO(b/172823566): Use mainline testToImmutableRangeMap once CollectorTester is usable to java7
  public void testToImmutableRangeMap() {
    Range<Integer> rangeOne = Range.closedOpen(1, 5);
    Range<Integer> rangeTwo = Range.openClosed(6, 7);

    ImmutableRangeMap.Builder<Integer, Integer> zis =

      if (name != null) path.removeAt(path.size - 1)
    }
  }

  /**
   * Execute [block] with a new namespace for type hints. Type hints from the enclosing type are no
   * longer usable by the current type's members.
   */
  fun <T> withTypeHint(block: () -> T): T {
    typeHintStack.add(null)
    try {
      return block()
    } finally {
      typeHintStack.removeAt(typeHintStack.size - 1)

    builder.add("a");
    assertEquals(1, builder.size);
    builder.add("b", "c", "d");
    assertEquals(4, builder.size);
    Object[] table = builder.hashTable;
    assertNotNull(table);
    assertSame(table, ((RegularImmutableSet<String>) builder.build()).table);
  }

  @GwtIncompatible("Builder impl")
  public void testPresizedBuilderForceCopy() {

        }

        // Query network interfaces from server
        queryRemoteInterfaces();

        // Discover local interfaces
        discoverLocalInterfaces();

        // Enable multi-channel if we have multiple usable interfaces
        if (canEnableMultiChannel()) {
            multiChannelEnabled = true;
            establishAdditionalChannels();