auth.close();

        // All these operations should throw IllegalStateException
        assertThrows(IllegalStateException.class, () -> auth.getPassword());
        assertThrows(IllegalStateException.class, () -> auth.getPasswordAsCharArray());
        assertThrows(IllegalStateException.class, () -> {
            // This would normally be called during authentication
            auth.createContext(null, null, "host", null, false);

    // Whenever both tests are cheap and functional, it's faster to use &, | instead of &&, ||
    "ShortCircuitBoolean")
abstract class AggregateFuture<InputT extends @Nullable Object, OutputT extends @Nullable Object>
    extends AggregateFutureState<OutputT> {
  private static final LazyLogger logger = new LazyLogger(AggregateFuture.class);

  /**
   * The input futures. After {@link #init}, this field is read only by {@link #afterDone()} (to

            }
        }
    }

    /**
     * Cleans up processed access results by updating their status in the data service.
     * This marks the access results as processed and clears the list.
     *
     * @param accessResultList the list of access results to clean up
     * @return the time taken for the cleanup operation in milliseconds, or -1 if no cleanup was needed
     */

        SmbTreeHandleImpl tree = fh.getTree();
        when(tree.send(any(Trans2SetFileInformation.class), any(Trans2SetFileInformationResponse.class), any(RequestParam.class)))
                .thenReturn(null);

        raf.setLength(200L);

        verify(tree, times(1)).send(any(Trans2SetFileInformation.class), any(Trans2SetFileInformationResponse.class),
                eq(RequestParam.NO_RETRY));
    }

    @Test

				return err
			}
		}
		if subdir == "." {
			break
		}
		subdir = filepath.Dir(subdir)
		dir = path.Join(dir, "..")
	}
	return nil
}

// adbCopyGoroot clears deviceRoot for previous versions of GOROOT, GOPATH
// and temporary data. Then, it copies relevant parts of GOROOT to the device,
// including the go tool built for android.

        public V setValue(final V value) {
            final V oldValue = this.value;
            this.value = value;
            return oldValue;
        }

        /**
         * Clears the state.
         */
        public void clear() {
            key = null;
            value = null;
            next = null;
        }

        @Override
        public boolean equals(final Object o) {

        return count;
    }

    /**
     * Clears a scroll context.
     *
     * @param scrollId The scroll ID to clear.
     */
    public void clearScroll(final String scrollId) {
        if (scrollId != null) {
            prepareClearScroll().addScrollId(scrollId)
                    .execute(ActionListener.wrap(res -> {}, e -> logger.warn("Failed to clear scroll context: scrollId={}", scrollId, e)));
        }
    }

        AtomicReferenceFieldUpdater.<Waiter, @Nullable Waiter>newUpdater(
            Waiter.class, Waiter.class, "next");
    private static final AtomicReferenceFieldUpdater<
            ? super AbstractFutureState<?>, @Nullable Waiter>
        waitersUpdater = newUpdater(AbstractFutureState.class, Waiter.class, "waitersField");
    private static final AtomicReferenceFieldUpdater<

import jcifs.internal.util.SMBUtil;
import jcifs.smb.SmbException;
import jcifs.util.Hexdump;

/**
 * Base class for SMB2/SMB3 protocol messages.
 *
 * This abstract class provides common functionality for all SMB2/SMB3
 * message types including encoding, decoding, and message handling.
 *
 * @author mbechler
 */
public abstract class ServerMessageBlock2 implements CommonServerMessageBlock {

    /*

        waiterThreadUpdater = lookup.findVarHandle(Waiter.class, "thread", Thread.class);
        waiterNextUpdater = lookup.findVarHandle(Waiter.class, "next", Waiter.class);
        waitersUpdater =
            lookup.findVarHandle(AbstractFutureState.class, "waitersField", Waiter.class);
        listenersUpdater =
            lookup.findVarHandle(AbstractFutureState.class, "listenersField", Listener.class);