assertEquals(24, SMBUtil.readInt2(buffer, 0));
        assertEquals(testFlags, SMBUtil.readInt2(buffer, 2));
    }

    @Test
    @DisplayName("writeBytesWireFormat with null file ID should handle gracefully")
    void testWriteBytesWireFormatWithNullFileId() {
        Smb2CloseRequest requestWithNull = new Smb2CloseRequest(mockConfig, null, testFileName);
        byte[] buffer = new byte[256];

        // Then
        assertEquals(0, bytesWritten);
        assertArrayEquals(originalBuffer, buffer); // Buffer should remain unchanged
    }

    @Test
    @DisplayName("Should handle null configuration gracefully")
    void testNullConfiguration() {
        // When - constructor accepts null config without throwing
        Smb2ReadResponse responseWithNull = new Smb2ReadResponse(null, outputBuffer, outputBufferOffset);

		EnvVar: "MINIO_CONSOLE_ADDRESS",
	},
	cli.DurationFlag{
		Name:   "shutdown-timeout",
		Value:  time.Second * 30,
		Usage:  "shutdown timeout to gracefully shutdown server (DEPRECATED)",
		EnvVar: "MINIO_SHUTDOWN_TIMEOUT",
		Hidden: true,
	},

	cli.DurationFlag{
		Name:   "idle-timeout",
		Value:  xhttp.DefaultIdleTimeout,

        assertNotNull(item.getTimestamp());
        assertNotNull(item.getId());
    }

    @Test
    public void testConstructorWithNullArrays() {
        // Test constructor handles null arrays gracefully
        String[] text = { "text" };
        String[][] readings = { { "reading" } };

        SuggestItem item = new SuggestItem(text, readings, null, 0L, 0L, 1.0f, null, null, null, SuggestItem.Kind.DOCUMENT);

    }

    /**
     * Test remove method with non-existing type
     */
    @Test
    @DisplayName("Remove should handle non-existing type gracefully")
    void testRemoveNonExisting() {
        List<AvPair> pairs = new LinkedList<>();
        AvTimestamp timestamp = new AvTimestamp(new byte[8]);
        pairs.add(timestamp);

            byte[] shortFileId = new byte[8];
            Arrays.fill(shortFileId, (byte) 0xAB);
            request.setFileId(shortFileId);

            byte[] buffer = new byte[256];

            // Should handle gracefully or throw appropriate exception
            assertThrows(ArrayIndexOutOfBoundsException.class, () -> request.writeBytesWireFormat(buffer, 0));
        }

        @Test

        ConfigurableRule rule = new ConfigurableRule();
        rule.setRuleId("nullTest");
        rule.setResponseProcessor(new TestResponseProcessor("nullProcessor"));

        // Should handle null gracefully
        assertFalse(rule.match(null));
    }

    /**
     * Test Rule with null rule ID
     */
    public void test_nullRuleId() {

     * Tests for edge cases and error conditions
     */
    @Nested
    @DisplayName("Edge Case Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle null configuration gracefully")
        void testNullConfiguration() {
            // When & Then - Should not throw exception
            assertDoesNotThrow(() -> {
                new Smb2TreeConnectResponse(null);

            ProtwordsFile errorFile = new ProtwordsFile("test_id", nonExistentFile.getAbsolutePath(), new Date());
            errorFile.reload(null);
            // If no exception, the file might have been handled gracefully
            assertTrue(true);
        } catch (Exception e) {
            // Expected for missing file
            assertTrue(true);
        }
    }

        }
    }

    @Nested
    @DisplayName("Encoding Tests")
    class EncodingTests {

        @Test
        @DisplayName("encode_in should handle null binding gracefully")
        void testEncodeInWithNullBinding() throws Exception {
            // Given
            when(mockHandle.getMaxXmit()).thenReturn(1024);
            when(mockHandle.getMaxRecv()).thenReturn(1024);