StackTraceElement[] causeStackTrace = cause.getStackTrace();

        assertNotNull(mainStackTrace);
        assertNotNull(causeStackTrace);
        assertTrue(mainStackTrace.length > 0);
        assertTrue(causeStackTrace.length > 0);

        // Stack traces should be different
        assertNotSame(mainStackTrace, causeStackTrace);
    }

    /**
     * Test printStackTrace functionality
     */

            totalLen = Math.max(SMB2_HEADER_LENGTH + body.length, ctxOffsetFromHeader + ctxBytes.length);
        } else {
            totalLen = SMB2_HEADER_LENGTH + body.length;
        }
        byte[] packet = new byte[totalLen];
        System.arraycopy(header, 0, packet, 0, header.length);
        System.arraycopy(body, 0, packet, SMB2_HEADER_LENGTH, body.length);
        if (ctxOffsetFromHeader != null && ctxBytes != null) {

        String directoryPath = "/test/integration";

        // Setup mock files
        when(mockFile1.getName()).thenReturn("document.txt");
        when(mockFile1.length()).thenReturn(2048L);
        when(mockFile1.lastModified()).thenReturn(System.currentTimeMillis() - 3600000);
        when(mockFile1.isDirectory()).thenReturn(false);

        }

        // Always compare full length to prevent timing leaks
        int lengthEqual = (a.length == b.length) ? 1 : 0;
        int maxLength = Math.max(a.length, b.length);

        int result = lengthEqual;
        for (int i = 0; i < maxLength; i++) {
            char charA = (i < a.length) ? a[i] : '\0';
            char charB = (i < b.length) ? b[i] : '\0';
            result &= (charA == charB) ? 1 : 0;

        writeInt4(filenameBytes.length, buffer, bufferIndex + 60); // fileNameLength

        // Copy filename into buffer at offset 94
        System.arraycopy(filenameBytes, 0, buffer, 94, filenameBytes.length);

        response.dataCount = 120;
        int bytesRead = response.readDataWireFormat(buffer, 0, buffer.length);

        assertEquals(response.dataCount, bytesRead);

        final Traverser[] traversers = TraversalUtil.getTraversers("org.codelibs.core.io.xxx");
        assertThat(traversers, is(notNullValue()));
        assertThat(traversers.length, is(1));

        final Traverser traverser = traversers[0];
        assertThat(traverser instanceof FileSystemTraverser, is(true));

        assertThat(traverser.isExistClass("DummyTest"), is(true));

    /**
     * Decode message data from the given byte array
     *
     * @param buffer the byte array containing the message data
     * @param bufferIndex the starting index in the buffer
     * @return message length
     * @throws SMBProtocolDecodingException if decoding fails
     */
    int decode(byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException;

    /**
     * Encodes this message into a byte array.
     *

            int bytesDecoded = buffer.decode(testBuffer, 0, testBuffer.length);

            assertEquals(8, bytesDecoded);
            assertEquals(0, buffer.getPathConsumed());
            assertEquals(0, buffer.getNumReferrals());
            assertEquals(0, buffer.getTflags());
            assertNotNull(buffer.getReferrals());
            assertEquals(0, buffer.getReferrals().length);
        }

        @Test

            final DateTimeFormatter formatter = DateTimeFormatter.ofPattern(YYYY_MM_DD_HH_MM);
            try {
                if (values.length > 0) {
                    cb.query().setRequestedAt_GreaterEqual(parseDateTime(values[0], formatter));
                }
                if (values.length > 1) {
                    cb.query().setRequestedAt_LessEqual(LocalDateTime.parse(values[1], formatter));
                }

        byte[] dst = new byte[expectedBytes.length];
        int dstIndex = 0;

        // Execute the method to write bytes
        int bytesWritten = smbComNegotiate.writeBytesWireFormat(dst, dstIndex);

        // Verify the number of bytes written
        assertEquals(expectedBytes.length, bytesWritten, "The number of bytes written should match the length of the dialect string.");