int bytesConsumed = response.decode(buffer, 0, 28);

        // Verify
        assertEquals(28, bytesConsumed, "Should consume exactly 28 bytes");

        byte[] resumeKey = response.getResumeKey();
        assertNotNull(resumeKey, "Resume key should not be null");
        assertEquals(24, resumeKey.length, "Resume key should be 24 bytes");

        // Verify resume key content
        for (int i = 0; i < 24; i++) {

        assertEquals(0, deleted);
        // Verify it used the same search logic (type parameter is ignored)
        verify(mockClient).prepareSearch("test-index");
    }

    /**
     * Test: Verify that OnConnectListener is properly invoked
     */
    @Test
    public void testOnConnectListenerInvoked() {

        logger.info(content);

        // Verify content contains expected fields
        assertTrue(content.contains("title"));
        assertTrue(content.contains("Sample Document"));
        assertTrue(content.contains("author"));
        assertTrue(content.contains("John Doe"));

        // Verify metadata extraction
        assertNotNull(extractData.getValues("title"));

        Assertions.assertEquals(19L, s);

        Mockito.verify(mock, Mockito.times(1)).getAttributes();
        Mockito.verify(mock, Mockito.times(1)).getCreateTime();
        Mockito.verify(mock, Mockito.times(1)).getLastWriteTime();
        Mockito.verify(mock, Mockito.times(1)).getLastAccessTime();
        Mockito.verify(mock, Mockito.times(1)).getSize();
        Mockito.verifyNoMoreInteractions(mock);
    }

        Map<String, ?> returned = entries[0].getOptions();

        // Assert: sanity check and verify that no mutating calls were made after construction
        assertEquals("true", returned.get("refreshKrb5Config"));
        verify(spyOpts, never()).put(any(), any());
        verify(spyOpts, never()).remove(any());
        verify(spyOpts, never()).clear();
    }

            ace.getAccessMask();

            // Different methods called
            ace.isAllow();
            ace.getFlags();

            verify(ace, times(2)).getAccessMask();
            verify(ace, times(1)).isAllow();
            verify(ace, times(1)).getFlags();
        }
    }

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

        @Test

import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.security.Principal;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

import java.util.function.Supplier;
import java.util.stream.Stream;

import org.junit.jupiter.api.DisplayName;

        final String content = extractData.getContent();
        logger.info(content);

        // Verify header extraction
        assertTrue(content.contains("Name"));
        assertTrue(content.contains("Email"));
        assertTrue(content.contains("Age"));
        assertTrue(content.contains("Department"));

        // Verify data extraction
        assertTrue(content.contains("John Doe"));

        assertEquals(0x00020000, v2.getValue());

        // Verify version ordering
        assertTrue(v2.getValue() > v1.getValue());
    }

    @Test
    void testWitnessEventTypes() {
        assertEquals(7, WitnessEventType.values().length);

        WitnessEventType[] events = WitnessEventType.values();

        // Verify all expected event types with correct values