user = User(username=oauth_header)
    return user


@app.get("/users/me")
def read_current_user(current_user: Optional[User] = Depends(get_current_user)):
    if current_user is None:
        return {"msg": "Create an account first"}
    return current_user


client = TestClient(app)


def test_security_api_key():
    response = client.get("/users/me", headers={"key": "secret"})

        assertArgumentNotNull("file", file);
        assertArgumentNotEmpty("encoding", encoding);

        final FileInputStream is = InputStreamUtil.create(file);
        try {
            final Reader reader = ReaderUtil.create(new BufferedInputStream(is, DEFAULT_BUF_SIZE), encoding);
            return read(reader, (int) ChannelUtil.size(is.getChannel()));
        } finally {
            CloseableUtil.close(is);

        private byte[] buffer;

        @BeforeEach
        void setUp() {
            buffer = new byte[BUFFER_SIZE];
        }

        @Test
        @DisplayName("Should create context with constructor parameters")
        void testConstructorWithParameters() {
            int[] hashAlgos = { PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512 };
            byte[] salt = new byte[32];

        CrawlingParameterUtil.setCrawlerContext(null);
        CrawlingParameterUtil.setUrlQueueService(null);
        CrawlingParameterUtil.setDataService(null);
        super.tearDown();
    }

    // Helper method to create a simple mock UrlQueue
    private UrlQueue<?> createMockUrlQueue(final String sessionId, final String url) {
        return new UrlQueue<Object>() {
            @Override
            public Object getId() {

        lenient().when(mockConfig.getDefaultDomain()).thenReturn("WORKGROUP");
        lenient().when(mockConfig.isUseUnicode()).thenReturn(true);
    }

    @Test
    @DisplayName("Should create Type 1 message with default flags")
    void testType1MessageCreation() {
        // When
        Type1Message type1 = new Type1Message(mockContext);

        // Then
        assertNotNull(type1);

    private byte[] verifyKey;
    private byte[] sealClientKey;
    private byte[] sealServerKey;

    private Cipher sealClientHandle;
    private Cipher sealServerHandle;

    /**
     * Creates a new NTLM security context with the specified parameters.
     * @param tc
     *            context to use
     * @param auth
     *            credentials
     * @param doSigning

public class SmbOperationExceptionTest {

    private SmbOperationException exception;

    @BeforeEach
    void setUp() {
        exception = null;
    }

    @Test
    @DisplayName("Should create exception with error code and message")
    void testBasicCreation() {
        // When
        exception = new SmbOperationException(SmbOperationException.ErrorCode.FILE_NOT_FOUND, "test.txt");

        // Then

    private static final int STRUCTURE_SIZE = 36;

    private int flags;
    private Smb2LeaseKey leaseKey;
    private int leaseState;

    /**
     * Create a lease break acknowledgment
     *
     * @param config configuration
     * @param leaseKey lease key
     * @param leaseState acknowledged lease state
     */

    /**
     * Create a new SmbOperationException
     *
     * @param errorCode the error code
     * @param message the error message
     */
    public SmbOperationException(ErrorCode errorCode, String message) {
        this(errorCode, message, null, RetryPolicy.DEFAULT, Collections.emptyMap());
    }

    /**
     * Create a new SmbOperationException with cause
     *

        }

        @Test
        @DisplayName("Should create instance with null ciphers")
        void testConstructorWithNullCiphers() {
            EncryptionNegotiateContext context = new EncryptionNegotiateContext(mockConfig, null);

            assertNotNull(context);
            assertNull(context.getCiphers());
        }

        @Test
        @DisplayName("Should create instance with empty ciphers array")