new ClassValue<Boolean>() {
            @Override
            protected Boolean computeValue(Class<?> type) {
              checkExceptionClassValidity(type.asSubclass(Exception.class));
              return true;
            }
          };

      @Override
      public void validateClass(Class<? extends Exception> exceptionClass) {

   * {@link SortedMultiset#entrySet}, and {@link SortedMultiset#remove(Object, int)}. In many
   * situations, you may wish to override {@link SortedMultiset#elementSet} to forward to this
   * implementation or a subclass thereof.
   *
   * @since 15.0
   */
  protected class StandardElementSet extends SortedMultisets.NavigableElementSet<E> {
    /** Constructor for use by subclasses. */
    public StandardElementSet() {

 * AbstractMapBasedMultimap} calls {@link #createCollection()} to create the collection of values
 * for that key. The subclass should not call {@link #createCollection()} directly, and a new
 * instance should be created every time the method is called.
 *
 * <p>For example, the subclass could pass a {@link java.util.TreeMap} during construction, and

   * {@link ForwardingMap#entrySet}. In many cases, you may wish to override {@link
   * ForwardingMap#keySet} to forward to this implementation or a subclass thereof.
   *
   * @since 10.0
   */
  protected class StandardKeySet extends Maps.KeySet<K, V> {
    /** Constructor for use by subclasses. */
    public StandardKeySet() {
      super(ForwardingMap.this);

    private static ClassOwnership detectJvmBehavior() {
      class LocalClass<T> {}
      Class<?> subclass = new LocalClass<String>() {}.getClass();
      // requireNonNull is safe because we're examining a type that's known to have a superclass.
      ParameterizedType parameterizedType =
          requireNonNull((ParameterizedType) subclass.getGenericSuperclass());
      for (ClassOwnership behavior : ClassOwnership.values()) {

              public void remove() {
                throw new IllegalStateException() {
                  /* subclass */
                };
              }

              @Override
              public Integer next() {
                throw new NoSuchElementException() {
                  /* subclass */
                };
              }

              @Override
              public boolean hasNext() {

   * {@link SortedMultiset#entrySet}, and {@link SortedMultiset#remove(Object, int)}. In many
   * situations, you may wish to override {@link SortedMultiset#elementSet} to forward to this
   * implementation or a subclass thereof.
   *
   * @since 15.0
   */
  protected class StandardElementSet extends SortedMultisets.NavigableElementSet<E> {
    /** Constructor for use by subclasses. */
    public StandardElementSet() {

        assertTrue(exception.getStackTrace().length > 0);
        assertNull(exception.getCause());
    }

    public void test_inheritance() {
        // Test that ResultOffsetExceededException is a subclass of FessSystemException
        ResultOffsetExceededException exception = new ResultOffsetExceededException("Test message");

        assertTrue(exception instanceof FessSystemException);

        assertEquals("single", item.getInputsValue());
    }

    public void test_getInputsValue_withNullInputs() {
        // Create item and then set inputs to null via reflection or subclass
        CharMappingItem item = new CharMappingItem(1L, new String[] { "temp" }, "output") {
            @Override
            public String getInputsValue() {
                // Simulate null inputs scenario

 * href="https://github.com/lukas-krecan/future-converter">Future Converter</a>.)
 *
 * <h3>Extension</h3>
 *
 * If you want a class like {@code FluentFuture} but with extra methods, we recommend declaring your
 * own subclass of {@link ListenableFuture}, complete with a method like {@link #from} to adapt an
 * existing {@code ListenableFuture}, implemented atop a {@link ForwardingListenableFuture} that
 * forwards to that future and adds the desired methods.