this.it = readers;
    advance();
  }

  /** Closes the current reader and opens the next one, if any. */
  private void advance() throws IOException {
    close();
    if (it.hasNext()) {
      current = it.next().openStream();
    }
  }

  @Override
  public int read(char[] cbuf, int off, int len) throws IOException {
    checkNotNull(cbuf);

  @Override
  public boolean hasNext() {
    return delegate().hasNext();
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public T next() {
    return delegate().next();
  }

  @Override
  public void remove() {
    delegate().remove();
  }

  @Override
  public final boolean hasNext() {
    return backingIterator.hasNext();
  }

  @Override
  @ParametricNullness
  public final T next() {
    return transform(backingIterator.next());
  }

  @Override
  public final void remove() {
    backingIterator.remove();
  }

        try {
          Event nextEvent;
          while ((nextEvent = queueForThread.poll()) != null) {
            while (nextEvent.subscribers.hasNext()) {
              nextEvent.subscribers.next().dispatchEvent(nextEvent.event);
            }
          }
        } finally {
          dispatching.remove();
          queue.remove();
        }
      }
    }

        printErrors(result);

        Iterator<Artifact> i = result.getArtifacts().iterator();
        assertEquals(n, i.next(), "n should be first");
        assertEquals(m, i.next(), "m should be second");

        // inverse order
        set = new LinkedHashSet<>();
        set.add(m);
        set.add(n);

     */
    @Override
    public void prepare(final CommonServerMessageBlockRequest next) {
        if (isReceived()) {
            ((ServerMessageBlock2) next).setTreeId(getTreeId());
        }
        super.prepare(next);
    }

    /**
     * Returns the type of the connected share (disk, pipe, or print).
     *
     * @return the shareType
     */

    assertThrows(
        ConcurrentModificationException.class,
        () -> {
          Iterator<Entry<K, V>> iterator = getMap().entrySet().iterator();
          getMap().remove(k0());
          iterator.next();
        });
  }

  @MapFeature.Require({FAILS_FAST_ON_CONCURRENT_MODIFICATION, SUPPORTS_REMOVE})
  @CollectionSize.Require(SEVERAL)
  public void testRemovePresentConcurrentWithKeySetIteration() {
    assertThrows(

            throw new NoAvailableChannelException("No healthy channels available");
        }

        if (availableChannels.size() == 1) {
            return availableChannels.iterator().next();
        }

        switch (strategy) {
        case ROUND_ROBIN:
            return selectRoundRobin(availableChannels);

        case LEAST_LOADED:
            return selectLeastLoaded(availableChannels);

		b.lastRead = opRead
	}
	return n, nil
}

// Next returns a slice containing the next n bytes from the buffer,
// advancing the buffer as if the bytes had been returned by [Buffer.Read].
// If there are fewer than n bytes in the buffer, Next returns the entire buffer.
// The slice is only valid until the next call to a read or write method.
func (b *Buffer) Next(n int) []byte {
	b.lastRead = opInvalid
	m := b.Len()

		tr := NewReader(&buf)
		h, err := tr.Next()
		if err != ErrInsecurePath {
			t.Errorf("tr.Next for file %q: got err %v, want ErrInsecurePath", path, err)
			continue
		}
		if h.Name != path {
			t.Errorf("tr.Next for file %q: got name %q, want %q", path, h.Name, path)
		}
		// Error should not be sticky.
		h, err = tr.Next()
		if err != nil {