// Test constructor with message only
        String message = "Test exception message";
        FessSystemException exception = new FessSystemException(message);

        assertEquals(message, exception.getMessage());
        assertNull(exception.getCause());
    }

    @Test
    public void test_constructor_withMessageAndCause() {
        // Test constructor with message and cause

    /**
     * @param message the message to give
     * @param e the {@link Exception}
     */
    public ToolchainsBuilderException(String message, Exception e) {
        super(message, e);
    }

    public ToolchainsBuilderException(String message, ProblemCollector<BuilderProblem> problems) {
        super(message, problems);
    }

    /**
     * @param message the message to give
     * @param e the {@link Exception}
     */
    public SettingsBuilderException(String message, Exception e) {
        super(message, e);
    }

    public SettingsBuilderException(String message, ProblemCollector<BuilderProblem> problems) {
        super(message, problems);
    }

     *
     * @return the command (human) name
     */
    @Nonnull
    String commandName();

    /**
     * Returns the logger to be used during the parsing process.
     *
     * @return the logger instance
     */
    @Nonnull
    Logger logger();

    /**
     * Returns the factory for creating message builders.
     *

 *    either peer may not have been transmitted to the other.
 *
 * Note that the state progression is independent for each peer. Arriving at a gracefully-closed
 * state indicates that a peer has sent all of its outgoing messages and received all of its
 * incoming messages. But it does not guarantee that the other peer will successfully receive all of
 * its incoming messages.
 *
 * ## Message Queue

    public MetadataRetrievalException(String message) {
        this(message, null, null);
    }

    public MetadataRetrievalException(Throwable cause) {
        this(null, cause, null);
    }

    public MetadataRetrievalException(String message, Throwable cause) {
        this(message, cause, null);
    }

    public MetadataRetrievalException(String message, Throwable cause, ArtifactMetadata artifact) {

        // Test the second step (processing Type 2 and creating Type 3 message)
        when(mockAuth.getDomain()).thenReturn(domain);
        when(mockAuth.getUsername()).thenReturn(username);
        when(mockAuth.getPassword()).thenReturn(password);
        NtlmContext context = new NtlmContext(mockAuth, true);

        // State 1: Generate Type 1 message
        context.initSecContext(new byte[0], 0, 0);

@Experimental
public class PrompterException extends MavenException {

    public PrompterException(String message) {
        super(message);
    }

    /**
     * @param message the message to give
     * @param e the {@link Exception}
     */
    public PrompterException(String message, Exception e) {
        super(message, e);
    }

    /**
     * Creates a new exception with the specified message.
     *
     * @param message the error message
     */
    public LlmException(final String message) {
        super(message);
        errorCode = ERROR_UNKNOWN;
    }

    /**
     * Creates a new exception with the specified message and cause.
     *
     * @param message the error message
     * @param cause the cause of the exception
     */

    }

    private void throwDockerRequiredException(final String message) {
        throwDockerRequiredException(message, null);
    }

    private void throwDockerRequiredException(final String message, Exception e) {
        throw new GradleException(
            message + "\nyou can address this by attending to the reported issue, or removing the offending tasks from being executed.",