try {
      assertFalse(
          "removeAll(emptyCollection) should return false or throw "
              + "UnsupportedOperationException",
          collection.removeAll(MinimalCollection.of()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)

   * <p>A collection is considered immutable if:
   *
   * <ol>
   *   <li>All its mutation methods result in UnsupportedOperationException, and do not change the
   *       underlying contents.
   *   <li>All methods that return objects that can indirectly mutate the collection throw
   *       UnsupportedOperationException when those mutators are called.
   * </ol>
   *
   * @param collection the presumed-immutable collection

   *
   * @deprecated unsupported operation
   * @throws UnsupportedOperationException always
   */
  @CanIgnoreReturnValue
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public @Nullable B put(TypeToken<? extends @NonNull B> key, @ParametricNullness B value) {
    throw new UnsupportedOperationException("Please use putInstance() instead.");
  }

  /**

  @SuppressWarnings("DoNotCall")
  public void testRemove() {
    Iterator<String> iterator = create();

    assertTrue(iterator.hasNext());
    assertEquals("a", iterator.next());
    assertThrows(UnsupportedOperationException.class, () -> iterator.remove());
  }

  @SuppressWarnings("DoNotCall")
  public void testAdd() {
    ListIterator<String> iterator = create();

    assertTrue(iterator.hasNext());

        throws ExecutionException, InterruptedException, TimeoutException {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean isShutdown() {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean isTerminated() {
      throw new UnsupportedOperationException();
    }

    @Override
    public void shutdown() {

    for (Table<Character, Integer, String> testInstance : getTestInstances()) {
      assertThrows(UnsupportedOperationException.class, () -> testInstance.clear());
    }
  }

  public final void testPut() {
    for (Table<Character, Integer, String> testInstance : getTestInstances()) {
      assertThrows(UnsupportedOperationException.class, () -> testInstance.put('a', 1, "blah"));
    }
  }

  public final void testPutAll() {

        throw new UnsupportedOperationException();
    }

    public static List<Plugin> orderAfterMerge(
            List<Plugin> merged, List<Plugin> highPrioritySource, List<Plugin> lowPrioritySource) {
        throw new UnsupportedOperationException();
    }

  /**
   * Guaranteed to throw an exception and leave the table unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final void clear() {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the table unmodified.

    }
  }

  @Override
  public void invalidateAll() {
    throw new UnsupportedOperationException();
  }

  @Override
  public CacheStats stats() {
    throw new UnsupportedOperationException();
  }

  @Override
  public ConcurrentMap<K, V> asMap() {
    throw new UnsupportedOperationException();
  }

  /**

    }

    @Override
    public E belowSamplesLesser() {
      throw new UnsupportedOperationException();
    }

    @Override
    public E belowSamplesGreater() {
      throw new UnsupportedOperationException();
    }

    @Override
    public E aboveSamplesLesser() {
      throw new UnsupportedOperationException();
    }

    @Override
    public E aboveSamplesGreater() {