assertEquals(0, bytesWritten, "Failed at iteration " + i);
            }
        }
    }

    @Nested
    @DisplayName("Error handling tests")
    class ErrorHandlingTests {

        @Test
        @DisplayName("Should provide clear error message for invalid structure size")
        void testClearErrorMessage() {
            // Given
            byte[] buffer = new byte[10];

        public boolean isVerifyFailed() {
            return this.verifyFailed;
        }

        @Override
        public boolean isError() {
            return this.error;
        }

        @Override
        public void error() {
            this.error = true;
        }

        // Setter methods for testing
        public void setGrantedCredits(int grantedCredits) {

            assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
                int dummy = WinError.WINERR_CODES[WinError.WINERR_CODES.length];
            });
        }
    }

    @Test
    @DisplayName("Mockito mock of WinError")
    void mockInterfaceNoOps() {
        WinError mock = Mockito.mock(WinError.class);
        assertNotNull(mock);

@ExtendWith(MockitoExtension.class)
class DosErrorTest {

    // Helper that performs a lookup over the constants exposed by DosError.
    // Returns -1 if the DOS code is not mapped.
    private static int findNtStatusOrMinusOne(int dosCode) {
        for (int[] pair : DosError.DOS_ERROR_CODES) {
            // each pair is [dosCode, ntStatus]
            if (pair != null && pair.length == 2 && pair[0] == dosCode) {

        } else {
          socket.close()
        }
      }

      ShutdownConnection -> {
        if (stream != null) {
          stream.connection.shutdown(ErrorCode.NO_ERROR)
        } else {
          socket.close()
        }
      }

      is CloseSocket -> {
        if (effect.shutdownInput) socket.shutdownInput()
        if (effect.shutdownOutput) socket.shutdownOutput()

    }

    /**
     * Test constructor DcerpcException(int error) with an unknown error code.
     */
    @Test
    void testConstructorWithError_unknownCode() {
        int errorCode = 0x12345678; // An arbitrary unknown error code
        DcerpcException exception = new DcerpcException(errorCode);

        assertEquals(errorCode, exception.getErrorCode(), "Error code should match the input.");

                .setLevel(Level.ERROR)
                .setMessage(new SimpleMessage("test error message"))
                .build();

        LogEvent result = policy.rewrite(event);

        assertNotSame(event, result);
        assertEquals(Level.WARN, result.getLevel());
        assertEquals("test.logger.sublogger", result.getLoggerName());
        assertEquals("test error message", result.getMessage().getFormattedMessage());

                Arguments.of(NbtException.ERR_NAM_SRVC, NbtException.SRV_ERR, "ERR_NAM_SRVC/Unknown error code: 2"),
                Arguments.of(NbtException.ERR_NAM_SRVC, NbtException.IMP_ERR, "ERR_NAM_SRVC/Unknown error code: 4"),
                Arguments.of(NbtException.ERR_NAM_SRVC, NbtException.RFS_ERR, "ERR_NAM_SRVC/Unknown error code: 5"),

        DataStoreException withIOException = new DataStoreException("IO Error", new java.io.IOException("File not found"));
        DataStoreException withNPE = new DataStoreException("NPE Error", new NullPointerException("Null value"));
        DataStoreException withCustom = new DataStoreException("Custom Error", new FessSystemException("System error"));

        assertTrue(withIOException.getCause() instanceof java.io.IOException);

            assertEquals(runtimeException, exception.getCause());
        });

        // Test with error
        Error error = new OutOfMemoryError("Out of memory");
        assertDoesNotThrow(() -> {
            RuntimeCIFSException exception = new RuntimeCIFSException(error);
            assertEquals(error, exception.getCause());
        });
    }

    @Test