int start = dstIndex;
            dstIndex += writeHeaderWireFormat(dst, dstIndex);
            dstIndex += writeBytesWireFormat(dst, dstIndex);

            // Set the length field that will be checked by ServerMessageBlock2Request.encode()
            int calculatedLength = testEncodedLength;
            setLength(calculatedLength);

        verify(tree, times(1)).close(); // try-with-resources must close
        verify(handle, never()).markClosed();
        verify(tree, never()).hasCapability(anyInt()); // not checked on SMB2
    }

    // SMB1 path: without CAP_NT_SMBS it should throw SmbUnsupportedOperationException
    @Test
    @DisplayName("watch() SMB1 without capability throws unsupported")

      }

      @Override
      public void run() {
        try {
          delegate.run();
        } catch (Throwable t) {
          // Any Exception is either a RuntimeException or sneaky checked exception.

          /*
           * We fail this `ListenableFuture`, whose result is exposed to the user through the
           * `ListenableScheduledTask` we return from the `schedule*` methods.
           */

		c.connChange.L.Unlock()
		// Happy path.
		return nil
	}
	ctx, cancel := context.WithCancel(ctx)
	defer cancel()
	changed := make(chan State, 1)
	go func() {
		defer xioutil.SafeClose(changed)
		for {
			c.connChange.Wait()
			newState := c.State()
			select {
			case changed <- newState:
				if newState == StateConnected || newState == StateShutdown {
					c.connChange.L.Unlock()
					return
				}

### Dateien und Async { #files-and-async }

In den meisten Fällen sind dateiähnliche Objekte standardmäßig nicht mit async und await kompatibel.

Beispielsweise haben sie kein `await file.read()` oder `async for chunk in file`.

Und in vielen Fällen wäre das Lesen eine blockierende Operation (die die Event-Loop blockieren könnte), weil von der Festplatte oder aus dem Netzwerk gelesen wird.

/// info | Info

      List<E> list, int index, Iterable<? extends E> elements) {
    boolean changed = false;
    ListIterator<E> listIterator = list.listIterator(index);
    for (E e : elements) {
      listIterator.add(e);
      changed = true;
    }
    return changed;
  }

  /** An implementation of {@link List#indexOf(Object)}. */

Refer to sizing guide for more understanding on default values chosen depending on your erasure stripe size [here](https://github.com/minio/minio/blob/master/docs/distributed/SIZING.md). Parity settings can be changed using [storage classes](https://github.com/minio/minio/tree/master/docs/erasure/storage-class).

### Consistency Guarantees

     * in O(n) time stepping through the two collections.
     */
    Iterator<E> thisIterator = iterator();

    Iterator<?> thatIterator = targets.iterator();
    // known nonempty since we checked targets.size() > 1

    if (!thisIterator.hasNext()) {
      return false;
    }

    Object target = thatIterator.next();
    E current = thisIterator.next();
    try {
      while (true) {

    private final Configuration cfg;
    private final int fid;
    private final byte[] fileId;
    private boolean open = true;
    private final long tree_num; // for checking whether the tree changed
    private SmbTreeHandleImpl tree;

    private final AtomicLong usageCount = new AtomicLong(1);
    private final int flags;
    private final int access;
    private final int attrs;
    private final int options;

 *
 * @since 3.0
 *         Builds one or more lifecycles for a full module
 *         NOTE: This class is not part of any public api and can be changed or deleted without prior notice.
 */
@Named
@Singleton
public class BuilderCommon {
    private final Logger logger;
    private final LifecycleDebugLogger lifecycleDebugLogger;