}

    @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 expiration;
        }

        @Override
        public void setExpiration(Long exp) {
            this.expiration = exp;
        }

        @Override
        public Exception getException() {
            return exception;
        }

        @Override
        public void exception(Exception e) {
            this.exception = e;
        }

        // Methods from Message interface

        void testExceptionState() {
            Exception testException = new RuntimeException("Test error");

            assertNull(testBlock.getException());

            testBlock.exception(testException);
            assertEquals(testException, testBlock.getException());
        }

        @Test
        @DisplayName("Test error state")
        void testErrorState() {
            assertFalse(testBlock.isError());

        }

        @Override
        public void exception(Exception e) {
            this.exception = e;
        }

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

        @Override
        public void setExpiration(Long expiration) {
            this.expiration = expiration;
        }

        @Override

            response.exception(testException);

            assertTrue(response.isError());
            assertTrue(response.isReceived());
            assertSame(testException, response.getException());
        }

        @Test
        @DisplayName("Should handle error")
        void testError() throws InterruptedException {
            CountDownLatch latch = new CountDownLatch(1);

         */
        public NetbiosAddress[] getAnswer() {
            return this.ans;
        }

        /**
         * @return the uhe
         */
        public UnknownHostException getException() {
            return this.uhe;
        }

    }

    NetbiosAddress[] lookupServerOrWorkgroup(final String name, final InetAddress svr) throws UnknownHostException {
        final Sem sem = new Sem(2);

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

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

    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Response#isError()
     */
    @Override

                        }

                        if (curResp.isError()) {
                            throw new TransportException(this.name + " error reading response to " + curReq, curResp.getException());
                        }
                        if (isDisconnected() && this.state != 5) {
                            throw new TransportException(