.put(AssertionFailedError.class, e -> e instanceof AssertionFailedError)
          .put(CancellationException.class, e -> e instanceof CancellationException)
          .put(ClassCastException.class, e -> e instanceof ClassCastException)
          .put(
              ConcurrentModificationException.class,
              e -> e instanceof ConcurrentModificationException)

      SortedSet<@Nullable Object> self = (SortedSet<@Nullable Object>) this;
      Object ceiling = self.tailSet(object).first();
      return unsafeCompare(comparator(), ceiling, object) == 0;
    } catch (ClassCastException | NoSuchElementException | NullPointerException e) {
      return false;
    }
  }

  /**
   * A sensible definition of {@link #remove} in terms of the {@code iterator()} method of {@link

   * than {@code upper}.
   *
   * @throws IllegalArgumentException if {@code lower} is greater than <i>or equal to</i> {@code
   *     upper}
   * @throws ClassCastException if {@code lower} and {@code upper} are not mutually comparable
   * @since 14.0
   */
  public static <C extends Comparable<?>> Range<C> open(C lower, C upper) {

   * {@code ClassCastException} for any elements {@code e1} and {@code e2} in the multiset. If the
   * user attempts to add an element to the multiset that violates this constraint (for example, the
   * user attempts to add a string element to a set whose elements are integers), the {@code
   * add(Object)} call will throw a {@code ClassCastException}.
   *

 * 
 * @author mbechler
 * @internal
 */
public interface DfsReferralData {

    /**
     * 
     * @param type
     * @return the referral adapted to type
     * @throws ClassCastException
     *             if the type is not valid for this object
     */
    <T extends DfsReferralData> T unwrap ( Class<T> type );


    /**
     * @return the server this referral points to
     */

   * {@code ClassCastException} for any elements {@code e1} and {@code e2} in the multiset. If the
   * user attempts to add an element to the multiset that violates this constraint (for example, the
   * user attempts to add a string element to a set whose elements are integers), the {@code
   * add(Object)} call will throw a {@code ClassCastException}.
   *

    assertThat(getCauseAs(thrown, SomeCheckedException.class)).isSameInstanceAs(cause);
    assertThat(getCauseAs(thrown, Exception.class)).isSameInstanceAs(cause);

    ClassCastException expected =
        assertThrows(
            ClassCastException.class, () -> getCauseAs(thrown, IllegalStateException.class));
    assertThat(expected).hasCauseThat().isSameInstanceAs(thrown);
  }

    try {
      // noinspection SuspiciousMethodCalls
      assertFalse(
          "containsKey(wrongType) should return false or throw",
          getMap().containsKey(WrongType.VALUE));
    } catch (ClassCastException tolerated) {
    }
  }

     * allowed, and will cause {@link #build} to fail.
     *
     * @throws NullPointerException if any key or value in {@code map} is null
     * @throws ClassCastException if any value is not an instance of the type specified by its key
     */
    @CanIgnoreReturnValue
    public <T extends B> Builder<B> putAll(Map<? extends Class<? extends T>, ? extends T> map) {

  }

  public void testGet_wrongType() {
    try {
      assertNull("get(wrongType) should return null or throw", getMap().get(WrongType.VALUE));
    } catch (ClassCastException tolerated) {
    }
  }