if _, err := io.ReadFull(r, buf[off:12]); err != nil {
		return err
	}
	b := readBuf(buf[:12])
	if b.uint32() != f.CRC32 {
		return ErrChecksum
	}

	// The two sizes that follow here can be either 32 bits or 64 bits
	// but the spec is not very clear on this and different
	// interpretations has been made causing incompatibilities. We
	// already have the sizes from the central directory so we can
	// just ignore these.

import java.util.concurrent.locks.LockSupport;
import org.jspecify.annotations.Nullable;
import sun.misc.Unsafe;

/** Supertype of {@link AbstractFuture} that contains platform-specific functionality. */
// Whenever both tests are cheap and functional, it's faster to use &, | instead of &&, ||
@SuppressWarnings("ShortCircuitBoolean")
@GwtCompatible
@ReflectionSupport(value = ReflectionSupport.Level.FULL)

  }

  /**
   * Associates the value {@code null} with the specified keys, assuming both keys are valid. If
   * either key is null or isn't among the keys provided during construction, this method has no
   * effect.
   *
   * <p>This method is equivalent to {@code put(rowKey, columnKey, null)} when both provided keys
   * are valid.
   *
   * @param rowKey row key of mapping to be erased

import jcifs.internal.smb2.nego.EncryptionNegotiateContext;
import jcifs.util.SecureKeyManager;

/**
 * SMB2/SMB3 Encryption Context
 *
 * Manages encryption and decryption operations for SMB2/SMB3 sessions.
 * Handles both AES-CCM (SMB 3.0/3.0.2) and AES-GCM (SMB 3.1.1) cipher suites.
 *
 * @author mbechler
 */
public class Smb2EncryptionContext implements AutoCloseable {

/**
 * Helper class for managing related content configurations.
 * This class provides functionality to load, cache, and retrieve related content
 * based on search queries and virtual host configurations. It supports both exact
 * term matching and regex pattern matching for flexible content association.
 */
public class RelatedContentHelper extends AbstractConfigHelper {

    /**
     * Default constructor for RelatedContentHelper.

        when(smbTree.unwrap(CustomSmbTree.class)).thenReturn(customTree);
        doNothing().when(smbTree).close();
        doNothing().when(customTree).close();

        // Unwrap then close both
        CustomSmbTree unwrapped = smbTree.unwrap(CustomSmbTree.class);
        smbTree.close();
        unwrapped.close();

        verify(smbTree).unwrap(CustomSmbTree.class);
        verify(smbTree).close();

import jcifs.internal.smb2.io.Smb2ReadRequest;
import jcifs.internal.smb2.io.Smb2ReadResponse;
import jcifs.util.transport.TransportException;

/**
 * This InputStream can read bytes from a file on an SMB file server. Offsets are 64 bits.
 */
public class SmbFileInputStream extends InputStream {

    private static final Logger log = LoggerFactory.getLogger(SmbFileInputStream.class);

    private SmbFileHandleImpl handle;
    private long fp;

        // Test path with trailing backslash (should be stripped)
        request.setPath("test\\directory\\");
        assertEquals("\\test\\directory", request.getPath());

        // Test path with both leading and trailing backslash
        request.setPath("\\test\\directory\\");
        assertEquals("\\test\\directory", request.getPath());

        // Test single backslash
        request.setPath("\\");

            assertTrue(context instanceof NegotiateContextResponse);
        }

        @Test
        @DisplayName("Should be usable as both request and response")
        void testDualInterfaceUsage() {
            EncryptionNegotiateContext context = new EncryptionNegotiateContext();

            NegotiateContextRequest request = context;

We want to get the `current_user` *only* if this user is active.

So, we create an additional dependency `get_current_active_user` that in turn uses `get_current_user` as a dependency.

Both of these dependencies will just return an HTTP error if the user doesn't exist, or if is inactive.

So, in our endpoint, we will only get a user if the user exists, was correctly authenticated, and is active: