if (result.hasExceptions()) {
            throw new ArtifactResolutionException(
                    "Unknown error during artifact resolution, " + request + ", " + result.getExceptions(),
                    request.getArtifact(),
                    request.getRemoteRepositories());
        }
    }

    private static <T> List<T> toList(Collection<T> items) {

                System.err.println("Missing: " + artifact);
            }
        }

        if (result.hasExceptions()) {
            for (Exception e : result.getExceptions()) {
                e.printStackTrace();
            }
        }
    }

    // ------------------------------------------------------------------------

    public boolean hasExceptions() {
        return exceptions != null && !exceptions.isEmpty();
    }

    public List<Exception> getExceptions() {
        return exceptions == null ? Collections.emptyList() : Collections.unmodifiableList(exceptions);
    }

    // ------------------------------------------------------------------------

    // ------------------------------------------------------------------------

    public boolean hasExceptions() {
        return exceptions != null && !exceptions.isEmpty();
    }

    public List<Exception> getExceptions() {
        return exceptions == null ? Collections.emptyList() : Collections.unmodifiableList(exceptions);
    }

    // ------------------------------------------------------------------------

    }

    @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);

        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

            ArtifactTransferResource artifact = wrap(event.getWagon().getRepository(), event.getResource());

            ArtifactTransferEvent evt;
            if (event.getException() != null) {
                evt = new ArtifactTransferEvent(wagon, event.getException(), event.getRequestType(), artifact);
            } else {
                evt = new ArtifactTransferEvent(wagon, event.getEventType(), event.getRequestType(), artifact);

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

            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")

     */
    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);

    /**