});

        try {
            fesenClient.get(c -> mockFuture);
            fail();
        } catch (RuntimeException e) {
            assertEquals("Persistent failure", e.getMessage());
        }

        // Should try initial + maxRetryCount times (1 + 3 = 4)
        assertEquals(4, attemptCount.get());
    }

    /**
     * Test: Null safety in connect() when targetIndices is null

            dcerpcBinding.setOption("endpoint", endpoint);
        }, "Should throw DcerpcException for unknown pipe endpoint.");

        assertTrue(thrown.getMessage().contains("Bad endpoint"), "Exception message should indicate a bad endpoint.");
    }

    @Test
    void testSetOptionEndpointInvalidFormat() {

        // Act & Assert
        IOException thrown = assertThrows(IOException.class, () -> {
            new LsaPolicyHandle(mockDcerpcHandle, server, access);
        });

        assertEquals("Network error", thrown.getMessage());
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarOpenPolicy2.class));
    }

    @Test
    void close_shouldClosePolicySuccessfully() throws IOException {
        // Arrange

        try {
            searchLogHelper.storeSearchLog();
        } catch (final Exception e) {
            logger.error("Failed to store a search log.", e);
            resultBuf.append(e.getMessage()).append("\n");
        }

        return resultBuf.toString();
    }

  @Override
  public final void tearDown() {
    try {
      sloppyTearDown();
    } catch (Throwable t) {
      logger.log(Level.INFO, "exception thrown during tearDown: " + t.getMessage(), t);
    }
  }

  public abstract void sloppyTearDown() throws Exception;

            securityDescriptor = new SecurityDescriptor();
            bufferIndex += securityDescriptor.decode(buffer, bufferIndex, len);
        } catch (final IOException ioe) {
            throw new RuntimeException(ioe.getMessage());
        }

        return bufferIndex - start;
    }

    @Override
    public String toString() {
        return ("NtTransQuerySecurityResponse[" + super.toString() + "]");
    }

        } catch (final Exception e) {
            logger.error("Could not delete expired documents: {}", queryBuilder, e);
            resultBuf.append(e.getMessage()).append("\n");
        }

        return resultBuf.toString();
    }

        assertEquals(NbtException.ERR_SSN_SRVC, e.errorClass);
        assertEquals(NbtException.CONNECTION_REFUSED, e.errorCode);
        assertEquals(e.getMessage(), NbtException.getErrorString(NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED));
    }

    @Test
    @DisplayName("toString includes class, code and error string")
    void testToString() {

                    () -> new Smb2SigningDigest(sessionKey, Smb2Constants.SMB2_DIALECT_0311, null));
            assertEquals("Missing preauthIntegrityHash for SMB 3.1.1", exception.getMessage());
        }

        @Test
        @DisplayName("Should throw exception for unknown dialect")
        void testConstructorUnknownDialect() {
            IllegalArgumentException exception =

            action.validateFilePath("");
            fail("Expected IllegalArgumentException");
        } catch (final IllegalArgumentException e) {
            assertTrue("Error message should indicate blank path: " + e.getMessage(), e.getMessage().contains("blank"));
        }
    }

    // ===================================================================================