verify(ace, times(1)).getFlags();
        }
    }

    @Nested
    @DisplayName("Real-world Usage Scenarios")
    class RealWorldUsageTests {

        @Test
        @DisplayName("Should handle typical file system permission scenarios")
        void shouldHandleFileSystemPermissions() {
            // Read-only file access

            assertEquals(FileSystemInformation.FS_FULL_SIZE_INFO, freshInfo.getFileSystemInformationClass());
        }
    }

    @Nested
    @DisplayName("Edge Cases and Real-World Scenarios")
    class EdgeCasesAndRealWorldTests {

        @Test
        @DisplayName("Should handle typical Windows NTFS configuration")
        void shouldHandleTypicalNTFSConfiguration() throws SMBProtocolDecodingException {

 * Due to the iterator's constructor calling advance() immediately, which requires
 * the adapt() method to be functional, we test the behavior using simple mock
 * scenarios that don't require complex filter setups.
 */
@ExtendWith(MockitoExtension.class)
class DirFileEntryAdapterIteratorTest {

    @Mock
    private SmbResource mockParent;

    @Mock

        doNothing().when(response).reset();
        response.reset();
        verify(response).reset();
    }

    @Test
    @DisplayName("Test concrete implementation with multiple scenarios")
    void testConcreteImplementation() throws SMBProtocolDecodingException {
        // Create a concrete implementation for comprehensive testing

     * Disabled by default - enable with -Dwitness.integration.test=true
     */
    @Test
    void testWitnessEnvironmentConfiguration() throws Exception {
        // Test simulating real witness environment scenarios
        // This test validates integration patterns without requiring real cluster

        // Simulate witness service discovery
        InetAddress mockWitnessAddress = InetAddress.getByName("127.0.0.1");

        assertEquals((byte) 0xFF, dst[1]);
        assertEquals((byte) 0xFF, dst[2]);
        assertEquals((byte) 0xFF, dst[3]);
    }

    @Test
    @DisplayName("Test writeUTime with DST scenarios")
    void testWriteUTimeWithDST() {
        when(mockConfig.getLocalTimezone()).thenReturn(mockTimeZone);

        byte[] dst = new byte[4];
        long testTime = System.currentTimeMillis();

                long minTime = timings.stream().mapToLong(Long::longValue).min().orElse(0L);

                double variance = (maxTime - minTime) / avgTime;
                // JVM timing in concurrent scenarios is inherently variable
                // We verify implementation correctness rather than precise timing
                assertTrue(variance < 50.0,
                        String.format(

import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;

/**
 * Security-focused test cases for Smb2NegotiateResponse input validation.
 * Tests various malformed input scenarios to ensure proper validation and
 * protection against buffer overflow, integer overflow, and other attacks.
 */
public class Smb2NegotiateResponseInputValidationTest {

    private Configuration mockConfig;

        assertEquals(TEST_CAPABILITIES, SMBUtil.readInt4(buffer, offset + 4)); // Capabilities
    }

    @Test
    @DisplayName("Should handle session binding scenarios")
    void testSessionBindingScenarios() throws Exception {
        // Test both true and false session binding
        boolean[] bindingValues = { true, false };

        for (boolean binding : bindingValues) {

     *
     * In high performance mode, expensive regex operations are avoided by doing
     * fast string contains checks first. This significantly improves performance
     * for high-frequency logging scenarios.
     *
     * @param enable true to enable high performance mode
     */
    public void setHighPerformanceModeEnabled(boolean enable) {
        this.enableHighPerformanceMode = enable;