Runnable command, long initialDelay, long period, TimeUnit unit) {
    throw new UnsupportedOperationException("scheduleAtFixedRate is not supported.");
  }

  @Override
  public ListenableScheduledFuture<?> scheduleWithFixedDelay(
      Runnable command, long initialDelay, long delay, TimeUnit unit) {
    throw new UnsupportedOperationException("scheduleWithFixedDelay is not supported.");
  }

    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  public void testRemoveUnsupported() {
    assertThrows(UnsupportedOperationException.class, () -> getMultiset().remove(e0(), 2));
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  public void testRemoveZeroNoOp() {
    int originalCount = getMultiset().count(e0());

    assertThrows(UnsupportedOperationException.class, () -> getMap().replace(k0(), v0(), v3()));
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testReplaceEntry_unsupportedWrongValue() {
    try {
      getMap().replace(k0(), v3(), v4());
    } catch (UnsupportedOperationException tolerated) {

   *
   * @throws UnsupportedOperationException if this {@link EndpointPair} is not ordered
   */
  public abstract N source();

  /**
   * If this {@link EndpointPair} {@link #isOrdered()}, returns the node which is the target.
   *
   * @throws UnsupportedOperationException if this {@link EndpointPair} is not ordered
   */
  public abstract N target();

  /**

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.exception;

/**
 * {@link UnsupportedOperationException}をラップする例外です。
 *
 * @author wyukawa
 */
public class ClUnsupportedOperationException extends UnsupportedOperationException {

    private static final long serialVersionUID = -6732367317955522602L;

    /**
     * {@link ClUnsupportedOperationException}を作成します。

    try {
      assertFalse(
          "removeIf(Predicate) should return false or throw " + "UnsupportedOperationException",
          collection.removeIf(
              x -> {
                throw new AssertionError("predicate should never be called");
              }));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)

    assertThrows(
        UnsupportedOperationException.class, () -> putAll(MinimalCollection.of(e3(), e0())));
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutAll_unsupportedAllPresent() {
    try {
      putAll(MinimalCollection.of(e0()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();

        transformValues(ImmutableMap.of("a", 1), Functions.toStringFunction());
    assertThrows(UnsupportedOperationException.class, () -> map.put("b", "2"));

    assertThrows(UnsupportedOperationException.class, () -> map.putAll(ImmutableMap.of("b", "2")));

    assertThrows(
        UnsupportedOperationException.class,
        () -> map.entrySet().iterator().next().setValue("one"));
  }

  }

  @ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
  @CollectionSize.Require(absent = ZERO)
  public void testAddAllAtIndex_unsupportedAllPresent() {
    assertThrows(
        UnsupportedOperationException.class, () -> getList().addAll(0, MinimalCollection.of(e0())));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  @CollectionSize.Require(absent = ZERO)

    /**
     * Exceptions should be {@link NullPointerException} or {@link UnsupportedOperationException}.
     */
    NPE_OR_UOE() {
      @Override
      public boolean isExpectedType(Throwable cause) {
        return cause instanceof NullPointerException
            || cause instanceof UnsupportedOperationException;
      }
    },

    /**