import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;

import jcifs.Configuration;

/**
 * Unit tests for {@link SmbComQueryInformation}.  The class is very small and
 * mainly focuses on serialising a command header that contains a file name.
 * <p>
 * Because most of the logic lives in {@link jcifs.internal.smb1.ServerMessageBlock}

        assertEquals("short", result);
    }

    @Test
    void testReadStringWithMaxLengthExceeded() {
        smb.useUnicode = false;
        byte[] buffer = "a very long string that exceeds max length".getBytes();
        assertThrows(RuntimeException.class, () -> {
            smb.readString(buffer, 0, 10, false);
        });
    }

    @Test
    void testEncodeDecode() {

        File file = cos.getFile();
        assertTrue(file.exists());
        cos.close();
    }

    @Test
    public void testLargeThreshold() throws IOException {
        // Test with very large threshold
        ContentOutputStream cos = new ContentOutputStream(1024 * 1024, Curl.tmpDir);
        cos.write(new byte[1000]);
        assertTrue(cos.isInMemory());
        cos.close();
    }

    @Test

        final int r = 32;
        final byte[] suffix = new byte[label.length + context.length + 5];
        // per bouncycastle
        // <li>1: K(i) := PRF( KI, [i]_2 || Label || 0x00 || Context || [L]_2 ) with the counter at the very beginning
        // of the fixedInputData (The default implementation has this format)</li>
        // with the parameters
        // <li>1. KDFCounterParameters(ki, null, "Label || 0x00 || Context || [L]_2]", 8);

        assertNull(exception.getCause());
    }

    /**
     * Test constructor with very long message
     */
    public void test_constructor_withVeryLongMessage() {
        StringBuilder longMessage = new StringBuilder();
        for (int i = 0; i < 10000; i++) {
            longMessage.append("Very long error message ");
        }
        String message = longMessage.toString();

        int actualInfoLevel = SMBUtil.readInt2(buffer, 0);
        assertEquals(0x0101, actualInfoLevel);
    }

    @Test
    void testWriteParametersWithLongFilename() {
        // Create a very long filename
        StringBuilder longPath = new StringBuilder();
        for (int i = 0; i < 100; i++) {
            longPath.append("verylongpath/");
        }
        longPath.append("file.txt");

        });
    }

    @Test
    @DisplayName("Test decode with maximum file name length")
    void testDecodeMaxFileNameLength() throws SMBProtocolDecodingException {
        // Create a very long filename (but within reasonable bounds)
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 255; i++) {
            sb.append('A');
        }
        String longFileName = sb.toString();

        long end = System.nanoTime();
        double totalTimeMs = (end - start) / 1_000_000.0;

        System.out.printf("Overall Performance Test: completed in %.2f ms%n", totalTimeMs);

        // Should complete very quickly with all optimizations
        assertTrue(totalTimeMs < 100, "All operations should complete quickly with performance fixes");

        pool.close();
    }

            sb.setLength(0); // Reset length
        }
        return sb;
    }

    private void returnStringBuilder(StringBuilder sb) {
        if (sb != null && sb.capacity() < 2048) { // Avoid keeping very large builders
            stringBuilderPool.offer(sb);
        }
    }

    private Map<String, Object> getContextMap() {
        HashMap<String, Object> map = mapPool.poll();
        if (map == null) {

    @DisplayName("Should handle long passwords")
    void testLongPasswords() throws Exception {
        // Given
        Type2Message type2 = createMockType2Message();
        String longPassword = createTestString(256); // Very long password

        // When/Then
        assertDoesNotThrow(() -> {
            Type3Message type3 = new Type3Message(createMockContext(), type2, null, longPassword, "DOMAIN", "user", "WORKSTATION", 0);