return collections;
                }
                throw new RuntimeException("Cannot get children of " + expected);
            }

            @Override
            public void describeTo(Description description) {
                description.appendText("same file collection as ").appendValue(expected);
            }
        };
    }

        super(id);
        this.matchingDescription = matchingDescription;
    }

    @Override
    public void describeTo(TreeFormatter builder) {
        matchingDescription.sort(DESCRIPTION_COMPARATOR);
        builder.node(getId().getVersion());
        builder.startChildren();

        return r.getProblems().stream()
                .anyMatch(p -> p.getLineNumber() == lineNumber && p.getColumnNumber() == columnNumber);
    }

    @Override
    public void describeTo(Description description) {
        description
                .appendText("a ProjectBuildingResult with location ")
                .appendText(formatLocation(columnNumber, lineNumber));
    }

}


private
fun repeat(char: Char, count: Int) = String(CharArray(count) { char })


private
fun doesNotExist(): Matcher<in File> = object : TypeSafeMatcher<File>() {

    override fun describeTo(description: Description) {
        description.appendText("nonexistent file")
    }

    override fun matchesSafely(file: File): Boolean = !file.exists()

    private String description;
    private int hashCode;

    public MethodModelRuleDescriptor(WeaklyTypeReferencingMethod<?, ?> method) {
        this.method = method;
    }

    @Override
    public void describeTo(Appendable appendable) {
        try {
            appendable.append(getDescription());
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

        }
    }

    private Matcher<FileCopyDetailsInternal> hasPath(final String path) {
        return new BaseMatcher<FileCopyDetailsInternal>() {
            void describeTo(Description description) {
                description.appendText("has path ").appendValue(path)
            }

            boolean matches(Object o) {
                FileCopyDetails details = (FileCopyDetails) o

    }

    String getStringDescription(MethodRuleDefinition ruleDefinition) {
        def builder = new StringBuilder()
        ruleDefinition.descriptor.describeTo(builder)
        builder.toString()
    }

    String getStringDescription(WeaklyTypeReferencingMethod<?, ?> method) {
        return MethodDescription.name(method.getName())

  template <typename Message>
  bool MatchAndExplain(const Message& p, testing::MatchResultListener*) const {
    return p.SerializeAsString() == expected_;
  }

  void DescribeTo(::std::ostream* os) const { *os << expected_; }
  void DescribeNegationTo(::std::ostream* os) const {
    *os << "not equal to expected message: " << expected_;
  }

 private:
  const std::string expected_;
};

            if (!expectedUserAgent.matches(actual)) {
                StringDescription description = new StringDescription();
                description.appendText("Expected user agent ");
                expectedUserAgent.describeTo(description);
                description.appendText(" but ");
                expectedUserAgent.describeMismatch(actual, description);
                String message = description.toString();

            this.readyToStartNodes = readyToStartNodes;
            this.otherNodes = otherWaitingNodes;
            this.eventItems = events;
        }

        public void describeTo(TreeFormatter formatter) {
            formatter.node(StringUtils.capitalize(displayName));
            formatter.startChildren();
            if (!queuedNodes.isEmpty()) {