assertThrows(SMBProtocolDecodingException.class, () -> notification.readBytesWireFormat(buffer, 0));

            assertEquals("Expected structureSize = 24", exception.getMessage());
        }

        @ParameterizedTest
        @DisplayName("Should read different oplock levels correctly")
        @ValueSource(bytes = { 0x00, 0x01, 0x02, 0x08, (byte) 0xFF })

            SMBProtocolDecodingException exception =
                    assertThrows(SMBProtocolDecodingException.class, () -> response.haveResponse(buffer, 0, 100));

            assertTrue(exception.getMessage().contains("Signature verification failed"));
        }
    }

    @Nested
    @DisplayName("Concurrency Tests")
    class ConcurrencyTests {

        @Test

        try {
            rateLimiter.checkAttempt(username, ip);
            fail("Should throw SmbException for locked account");
        } catch (SmbException e) {
            assertTrue(e.getMessage().contains("locked out"), "Should indicate account lockout");
        }
    }

    @Test
    public void testIpRateLimit() throws Exception {
        String ip = "192.168.1.3";

        try {
            charMappingFile.update(updateItem2);
            fail("Should throw DictionaryException");
        } catch (DictionaryException e) {
            assertTrue(e.getMessage().contains("Mapping file was updated"));
        }
    }

    // Test reload with IOException
    public void test_reload_ioException() throws Exception {
        // This test verifies error handling during reload

        SMBProtocolDecodingException exception =
                assertThrows(SMBProtocolDecodingException.class, () -> response.readBytesWireFormat(buffer, 0));
        assertEquals("Expected structureSize = 9", exception.getMessage());
    }

    @Test
    @DisplayName("Should handle empty notification list")
    void testEmptyNotificationList() throws Exception {
        // Given
        byte[] buffer = new byte[256];

            fail("Should throw IllegalArgumentException for negative boost");
        } catch (IllegalArgumentException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("negative [boost] are not allowed"));
        }
    }

    public void test_execute_multipleInvocations() {
        // Test that multiple invocations return consistent results

	public final fun getHeaders ()Lokhttp3/Headers;
	public final fun getHeadersDelayNanos ()J
	public final fun getInTunnel ()Z
	public final fun getInformationalResponses ()Ljava/util/List;
	public final fun getMessage ()Ljava/lang/String;
	public final fun getOnRequestBody ()Lmockwebserver3/SocketEffect;
	public final fun getOnRequestStart ()Lmockwebserver3/SocketEffect;
	public final fun getOnResponseBody ()Lmockwebserver3/SocketEffect;

            // When/Then: Should propagate IOException
            IOException thrown = assertThrows(IOException.class, () -> spyHandle.bind());
            assertEquals("Test IO Exception", thrown.getMessage());
        }
    }

    @Nested
    @DisplayName("Send/Receive Tests")
    class SendReceiveTests {

        @Test
        @DisplayName("Should handle basic send/receive fragment methods")

        ndrBuffer.setIndex(0);
        NdrException thrown = assertThrows(NdrException.class, () -> {
            ndrBuffer.dec_ndr_string();
        });
        assertEquals(NdrException.INVALID_CONFORMANCE, thrown.getMessage());
    }

    @Test
    void testEncNdrReferent() {
        Object obj1 = new Object();
        Object obj2 = new Object();

        // Test unique/ref type (type 1 or 3)

            assertEquals("maxKey() return type should be String", String.class, maxKeyMethod.getReturnType());
        } catch (final NoSuchMethodException e) {
            fail("Required annotation method not found: " + e.getMessage());
        }
    }

    // Test creating custom implementation of annotation
    public void test_customAnnotationImplementation() {
        final CustomSize customAnnotation = new CustomSize() {