when(mockResponse.getException()).thenReturn(testException);
        assertEquals(testException, mockResponse.getException());

        // Test null exception
        when(mockResponse.getException()).thenReturn(null);
        assertNull(mockResponse.getException());

        // Verify the method was called
        verify(mockResponse, times(2)).getException();
    }

    @Test

    }

    @Test
    @DisplayName("Test Response interface methods - getException")
    void testGetException() {
        // Given
        Exception expectedException = new Exception("Test exception");
        when(response.getException()).thenReturn(expectedException);

        // When
        Exception actualException = response.getException();

        // Then
        assertEquals(expectedException, actualException);

            assertFalse(echoResponse.isReceived());
            assertNull(echoResponse.getException());

            echoResponse.exception(testException);

            assertTrue(echoResponse.isError());
            assertTrue(echoResponse.isReceived());
            assertEquals(testException, echoResponse.getException());
        }

        @Test
        @DisplayName("Should clear received state")

                            return buffer.toString();
                        }

                        @Override
                        public Exception getException() {
                            return problem.getException();
                        }

                        @Override
                        public String getMessage() {
                            return problem.getMessage();

            } catch (PrivilegedActionException e) {
                if (e.getException() instanceof SmbException) {
                    throw (SmbException) e.getException();
                }
                throw new SmbException("Unexpected exception during context initialization", e);
            }
        }

    @Override
    public CacheRecord get(Key key) throws LifecycleExecutionException {
        CacheRecord cacheRecord = cache.get(key);
        if (cacheRecord != null && cacheRecord.getException() != null) {
            throw cacheRecord.getException();
        }
        return cacheRecord;
    }

    @Override
    public CacheRecord put(Key key, Set<Artifact> projectArtifacts) {

        this.asyncHandled = asyncHandled;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#getException()
     */
    @Override
    public Exception getException() {
        return this.exception;
    }

    /**
     *
     * @return error status code
     */
    @Override
    public final int getErrorCode() {

     */
    void reset();

    /**
     * Gets the exception associated with this response.
     *
     * @return an exception linked to an error
     */
    Exception getException();

    /**
     * Sets an exception for this response.
     *
     * @param e the exception to set
     */
    void exception(Exception e);

    /**

                                "Failed to process POM for " + artifact.getId() + ": " + missingParentPom.getMessage(),
                                missingParentPom.getException(),
                                artifact);
                    }

                    String message;

                    if (isMissingPom(e)) {

                versionIndex.put(version, workspace.getRepository());
            }
        }

        for (MetadataResult metadataResult : metadataResults) {
            result.addException(metadataResult.getException());

            ArtifactRepository repository = metadataResult.getRequest().getRepository();
            if (repository == null) {
                repository = session.getLocalRepository();
            }