*/
    @Override
    public void close () {
        // nothing to clean up
        this.next = null;
    }

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

    assertThrows(NoSuchElementException.class, () -> iterator.previous());
    assertThrows(UnsupportedOperationException.class, () -> iterator.remove());
    assertThrows(UnsupportedOperationException.class, () -> iterator.set("a"));
    assertThrows(UnsupportedOperationException.class, () -> iterator.add("a"));
  }

  public void testEmptyModifiableIterator() {

        return this.smb2;
    }


    /**
     * @return the dialect
     */
    public final int getDialect () {
        if ( !this.smb2 ) {
            throw new UnsupportedOperationException();
        }
        return this.dialect;
    }


    /**
     * 
     * @param v
     * @return whether this version is a least the given one
     */

  @ListFeature.Require(absent = SUPPORTS_REMOVE_WITH_INDEX)
  @CollectionSize.Require(absent = ZERO)
  public void testRemoveAtIndex_unsupported() {
    assertThrows(UnsupportedOperationException.class, () -> getList().remove(0));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
  public void testRemoveAtIndex_negative() {

 *
 * <pre>
 * class Unsupported extends AbstractInvocationHandler {
 *   protected Object handleInvocation(Object proxy, Method method, Object[] args) {
 *     throw new UnsupportedOperationException();
 *   }
 * }
 *
 * CharSequence unsupported = Reflection.newProxy(CharSequence.class, new Unsupported());
 * </pre>
 *
 * @author Ben Yu
 * @since 12.0
 */
@ElementTypesAreNonnullByDefault

      @Override
      public Appendable append(@CheckForNull CharSequence chars, int off, int len) {
        throw new UnsupportedOperationException();
      }

      @Override
      public Appendable append(@CheckForNull CharSequence chars) {
        throw new UnsupportedOperationException();
      }
    };
  }

  @J2ktIncompatible
  @GwtIncompatible // Writer

  /*
   * absent = ZERO isn't required, since unmodList.add() must
   * throw regardless, but it keeps the method name accurate.
   */
  public void testAdd_unsupportedPresent() {
    assertThrows(UnsupportedOperationException.class, () -> getList().add(e0()));
  }

  @CollectionFeature.Require(value = {SUPPORTS_ADD, ALLOWS_NULL_VALUES})
  @CollectionSize.Require(absent = ZERO)
  public void testAdd_supportedNullPresent() {

        if (node instanceof Text) {
            target.append(node.nodeValue.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;'))
            return
        }

        throw new UnsupportedOperationException("Don't know how to format DOM node: $node")
    }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(absent = SUPPORTS_REMOVE)
  public void testClearUnsupported() {
    assertThrows(UnsupportedOperationException.class, () -> multimap().clear());
  }

  private void assertCleared() {
    assertEquals(0, multimap().size());
    assertEmpty(multimap());
    assertEquals(multimap(), getSubjectGenerator().create());

public class MultimapPutAllMultimapTester<K, V>
    extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testPutUnsupported() {
    assertThrows(
        UnsupportedOperationException.class,
        () -> multimap().putAll(getSubjectGenerator().create(mapEntry(k3(), v3()))));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutAllIntoEmpty() {