expect:
        progressOperation.getMessage() == "STATUS"
    }

    def "message is null if all inputs are null"() {
        given:
        ProgressOperation progressOperation = new ProgressOperation(null, "VARIANT_CATEGORY", new OperationIdentifier(1), null)

        expect:
        progressOperation.getMessage() == null
    }

    def "allows children to be managed"() {
        given:

        then:
        def ex = thrown(IllegalStateException)
        1 * context.getProjectPath() >> Path.path('foo')
        ex.getMessage().contains('Dependency locking cannot be used for project')
        ex.getMessage().contains('foo')
    }

    def 'fails to read a legacy lockfile if root could not be determined'() {
        FileResolver resolver = Mock()

                throw new WrongExceptionThrownError(annotation.type(), t);
            }
            if (!annotation.message().equals(t.getMessage())) {
                throw new ComparisonFailure("Unexpected message for exception.", annotation.message(), t.getMessage());
            }
        }
    }

    }

    public Exception getException() {
        return exception;
    }

    public String getMessage() {
        String msg;

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

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

        return msg;

        final Supplier<String> stacktraceString = () -> {
            final StringBuilder sb = new StringBuilder();
            if (StringUtil.isBlank(cause.getMessage())) {
                sb.append(cause.getClass().getName());
            } else {
                sb.append(cause.getMessage());
            }
            try (final StringWriter sw = new StringWriter(); final PrintWriter pw = new PrintWriter(sw)) {

    public String getExceptionClassName() {
        return exceptionClassName;
    }

    @Override
    public String getMessage() {
        if (getMessageException != null) {
            throw UncheckedException.throwAsUncheckedException(getMessageException);
        }
        return super.getMessage();
    }

    @Override
    public String toString() {
        if (toStringRuntimeEx != null) {

  }

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

  public Object getSource() {
    return source;
  }

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

  private static final long serialVersionUID = 0;

    public DescriptiveChange(String message, Object... params) {
        this.message = String.format(message, params);
    }

    @Override
    public String getMessage() {
        return message;
    }

    @Override
    public String toString() {
        return getMessage();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

                            loc != null ? loc.getLineNumber() : -1,
                            loc != null ? loc.getColumnNumber() : -1,
                            e,
                            e.getMessage(),
                            BuilderProblem.Severity.WARNING));
                }
            }
        } catch (XmlReaderException e) {

        assertForbidden(name, exception.getMessage())

        where:
        name << invalidNames
    }

    def "#objectType are not allowed to be named '#name'"() {
        when:
        domainObjectContainer.create(name)

        then:
        def exception = thrown(InvalidUserDataException)
        assertForbidden(name, exception.getMessage())

        where: