@Test
    @DisplayName("EmptyIterator should behave consistently across multiple calls")
    void testConsistentBehavior() {
        // When & Then - test multiple sequential calls
        for (int i = 0; i < 10; i++) {
            assertFalse(emptyIterator.hasNext(), "hasNext should consistently return false");
            assertNull(emptyIterator.next(), "next should consistently return null");
        }
    }

    @RepeatedTest(5)

        // This is expected behavior since they're created with the same configuration
        assertEquals(response1.toString(), response2.toString());
    }

    @Test
    @DisplayName("All write methods should consistently return 0")
    void testAllWriteMethodsReturnZero() {
        // Arrange
        byte[] buffer = new byte[100];

        // Act & Assert
        assertEquals(0, response.writeSetupWireFormat(buffer, 0));

    @DisplayName("Test implementation consistency")
    void testImplementationConsistency() {
        // Given
        SmbNegotiationRequest consistentRequest = new TestSmbNegotiationRequest(true);

        // When & Then - verify consistency across multiple calls
        for (int i = 0; i < 10; i++) {
            assertTrue(consistentRequest.isSigningEnforced(), "Implementation should consistently return the same value");
        }

        // Then - should be same instances
        assertSame(config1, config2, "Configuration should be consistent");
        assertSame(dfs1, dfs2, "DFS resolver should be consistent");
        assertSame(cache1, cache2, "Buffer cache should be consistent");
    }

    @Test
    @DisplayName("Context should provide working resource creation")

        @Test
        @DisplayName("Should always force unicode")
        void testIsForceUnicode() {
            assertTrue(response.isForceUnicode());
        }

        @Test
        @DisplayName("Should consistently return true for unicode")
        void testIsForceUnicodeMultipleCalls() {
            for (int i = 0; i < 5; i++) {
                assertTrue(response.isForceUnicode());
            }
        }
    }

        // Call readBytesWireFormat multiple times
        for (int i = 0; i < 5; i++) {
            int result = response.readBytesWireFormat(buffer, bufferIndex);
            assertEquals(2, result, "Should consistently return 2 on call " + (i + 1));
        }
    }

    @Test
    @DisplayName("Test edge case with maximum buffer index")
    void testReadBytesWireFormatMaxBufferIndex() throws SMBProtocolDecodingException {

            assertFalse(auth1.equals(auth3));

            // Test empty vs password
            assertFalse(auth2.equals(auth3));

            // These operations should complete quickly and consistently
            long startTime = System.nanoTime();
            for (int i = 0; i < 1000; i++) {
                auth1.equals(auth2);
                auth1.equals(auth3);
                auth2.equals(auth3);

        }
    }

    @Nested
    @DisplayName("Edge Case Tests")
    class EdgeCaseTest {

        @Test
        @DisplayName("Should handle repeated method calls consistently")
        void shouldHandleRepeatedMethodCallsConsistently() {
            SmbSession mockSession = mock(SmbSession.class);
            Configuration mockConfig = mock(Configuration.class);

            jcifs.CIFSContext context = createDefaultContext();

            // Create transport with multi-channel specific settings
            // Multi-channel transports should use signing consistently with the main session
            boolean forceSigning = context.getConfig().isSigningEnforced();

            assertEquals(200L, SMBUtil.readInt8(smallBuffer, 8));
            assertEquals(1, SMBUtil.readInt4(smallBuffer, 16));
        }

        @ParameterizedTest
        @DisplayName("Should encode consistently with various flag values")
        @ValueSource(ints = { 0, 1, 2, 4, 16, 0xFF, 0xFFFF, 0xFFFFFF, 0x7FFFFFFF, -1 })
        void testEncodingWithVariousFlags(int flags) {
            lock = new Smb2Lock(1024L, 2048L, flags);