final ConverterRuntimeException e = new ConverterRuntimeException("hoge", "xxx", new RuntimeException("cause"));
        System.out.println(e.getMessage());
        assertThat(e.getPropertyName(), is("hoge"));
        assertThat(e.getValue(), is((Object) "xxx"));
        assertThat(e.getCause().getMessage(), is("cause"));
    }

    public void transferFailed(TransferEvent event) {
        transferCompleted(event);

        println(
                "transferFailed",
                event.getException().getClass() + ": " + event.getException().getMessage());
    }

    private void transferCompleted(TransferEvent event) {
        downloads.remove(event.getResource());

        StringBuilder buffer = new StringBuilder(64);
        pad(buffer, lastLength);

        assertEquals("Type1", exception1.getType());
        assertEquals("Message1", exception1.getMessage());
        assertEquals("Type2", exception2.getType());
        assertEquals("Message2", exception2.getMessage());

        assertNotSame(exception1, exception2);
    }

    @Test
    public void test_serialVersionUID() {

    void release_belowZero_throws() {
        SmbTreeConnection c = newConn();
        RuntimeCIFSException ex = assertThrows(RuntimeCIFSException.class, c::release);
        assertTrue(ex.getMessage().toLowerCase().contains("usage count"));
    }

    @Test
    @DisplayName("isConnected reflects underlying tree state")
    void isConnected_usesTree() {
        SmbTreeConnection c = newConn();

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

    @Override
    public String getMessage() {
        String msg;

        if (message != null && !message.isEmpty()) {
            msg = message;
        } else {
            msg = exception.getMessage();

            if (msg == null) {
                msg = "";
            }
        }

        return msg;

    }

    private static String getMessage(Throwable error, String def) {
        if (error == null) {
            return def;
        }
        String msg = error.getMessage();
        if (msg != null && !msg.isEmpty()) {
            return msg;
        }
        return getMessage(error.getCause(), def);
    }

  }

  public Set<Feature<?>> getConflicts() {
    return conflicts;
  }

  public Object getSource() {
    return source;
  }

  @Override
  public String getMessage() {
    return super.getMessage() + " (source: " + source + ")";
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

        NullPointerException npe1 = assertThrows(NullPointerException.class, () -> filter.accept(null, "x"));
        assertTrue(npe1.getMessage().contains("non-null"));

        NullPointerException npe2 = assertThrows(NullPointerException.class, () -> filter.accept(mockDir, null));
        assertTrue(npe2.getMessage().contains("non-null"));
        verifyNoInteractions(mockDir);
    }

    /**

        messages = new ArrayList<>();
    }

    public int getMessageCount() {
        return messages.size();
    }

    public String getMessage(int i) {
        return messages.get(i);
    }

    public List<String> getMessages() {
        return Collections.unmodifiableList(messages);
    }

    public void addMessage(String message) {
        messages.add(message);
    }

    }

    public ModelProblemCollectorRequest setException(Exception exception) {
        this.exception = exception;
        return this;
    }

    public String getMessage() {
        return message;
    }

    public ModelProblemCollectorRequest setMessage(String message) {
        this.message = message;
        return this;
    }

    public InputLocation getLocation() {
        return location;
    }