*/
    @Override
    public void prepare ( CommonServerMessageBlockRequest next ) {
        if ( isReceived() && ( next instanceof RequestWithFileId ) ) {
            ( (RequestWithFileId) next ).setFileId(this.fileId);
        }
        super.prepare(next);
    }


    /**
     * @return the oplockLevel
     */
    public final byte getOplockLevel () {

                    }

                    @Override
                    public Entry<String, String> next() {
                      return transform(iterator.next());
                    }

                    private Entry<String, String> transform(final Entry<String, String> next) {
                      return new Entry<String, String>() {

                        @Override

      int initialSize = map.size();
      boolean didRemove = entrySet.remove(entrySet.iterator().next());
      assertTrue(didRemove);
      assertEquals(initialSize - 1, map.size());
    } else {
      assertThrows(
          UnsupportedOperationException.class, () -> entrySet.remove(entrySet.iterator().next()));
    }
    assertInvariants(map);
  }

  public void testEntrySetRemoveMissingKey() {

    assertEquals(
        "multiset.entrySet() iterator.next() returned incorrect entry",
        Multisets.immutableEntry(e0(), 1),
        iterator.next());
    assertFalse(
        "size 1 multiset.entrySet() iterator.hasNext() returned true after next()",
        iterator.hasNext());
    iterator.remove();
    assertTrue(

        case CLOSED:
          C next = domain.next(endpoint);
          return (next == null) ? Cut.<C>belowAll() : belowValue(next);
      }
      throw new AssertionError();
    }

    @Override
    Cut<C> withUpperBoundType(BoundType boundType, DiscreteDomain<C> domain) {
      switch (boundType) {
        case OPEN:
          C next = domain.next(endpoint);

            }
          }
        };

    assertTrue(iter.hasNext());
    assertEquals(0, (int) iter.next());

    // verify idempotence of hasNext()
    assertTrue(iter.hasNext());
    assertTrue(iter.hasNext());
    assertTrue(iter.hasNext());
    assertEquals(1, (int) iter.next());

    assertFalse(iter.hasNext());

    // Make sure computeNext() doesn't get invoked again

  private int position;

  /** Returns the element with the specified index. This method is called by {@link #next()}. */
  @ParametricNullness
  protected abstract E get(int index);

  /**
   * Constructs an iterator across a sequence of the given size whose initial position is 0. That
   * is, the first call to {@link #next()} will return the first element (or throw {@link
   * NoSuchElementException} if {@code size} is zero).
   *

    final Runnable runnable;
    final Executor executor;
    @CheckForNull RunnableExecutorPair next;

    RunnableExecutorPair(
        Runnable runnable, Executor executor, @CheckForNull RunnableExecutorPair next) {
      this.runnable = runnable;
      this.executor = executor;
      this.next = next;
    }
  }

     */
    public boolean chain ( ServerMessageBlock2 n ) {
        if ( this.next != null ) {
            return this.next.chain(n);
        }

        n.addFlags(SMB2_FLAGS_RELATED_OPERATIONS);
        this.next = n;
        return true;
    }


    protected ServerMessageBlock2 getNext () {
        return this.next;
    }


    protected void setNext ( ServerMessageBlock2 n ) {

                        for (Object next : feedback) {
                            if (next instanceof Throwable) {
                                if (last == null) {
                                    logger.debug("", ((Throwable) next));
                                } else {
                                    logger.debug(String.valueOf(last), ((Throwable) next));
                                }