int count = Math.min(5, values.size());
        for (int i = 0; i < count; i++) {
            Object next = iterator.next();
            if (next instanceof RejectedVersion) {
                ((RejectedVersion) next).describeTo(builder);
            } else {
                builder.node(next.toString());
            }
        }
        if (count < values.size()) {

                StringBuilder sb = new StringBuilder();
                ruleDefinition.getDescriptor().describeTo(sb);
                sb.append(String.format(" is not a valid %s model rule method.", modelName));
                return new InvalidModelRuleDeclarationException(sb.toString(), e);
            }
        }
    }

            @Override
            protected boolean matchesSafely(T item) {
                return match.test(item)
            }

            @Override
            void describeTo(Description description) {
                describe.accept(description)
            }
        }
    }

    protected static String normalizedPathOf(File file) {

        modelRegistry.transition(this, state, true);
    }

    private static String describe(ModelRuleDescriptor descriptor) {
        StringBuilder stringBuilder = new StringBuilder();
        descriptor.describeTo(stringBuilder);
        return stringBuilder.toString();
    }

            this.version = version;
        }


        @Override
        public String getDisplayName() {
            TreeFormatter formatter = new TreeFormatter();
            version.describeTo(formatter);
            return "version " + formatter;
        }
    }

    private static class RejectedBySelectorReason implements Describable {

        private final Collection<String> rejectedVersions;

    }

    private static Matcher<PatternMatcher> matches(final String[] segments, final boolean isFile) {
        return new BaseMatcher<PatternMatcher>() {
            public void describeTo(Description description) {
                description.appendText("matches ").appendValue(Joiner.on("/").join(segments));
            }

            public boolean matches(Object o) {

                    return false
                }
                assertHasConsoleSummary(item.toString(), spec)
                return true
            }

            @Override
            void describeTo(Description description) {
                description.appendText("contains expected problems")
            }
        }
    }

    private static void assertNoProblemsSummary(String text) {

      assertThat(listener.recordedEventTypes()).doesNotContain("ResponseBodyEnd")
    }
  }

  private fun greaterThan(value: Long): Matcher<Long?> {
    return object : BaseMatcher<Long?>() {
      override fun describeTo(description: Description?) {
        description!!.appendText("> $value")
      }

      override fun matches(o: Any?): Boolean {
        return (o as Long?)!! > value
      }
    }
  }

                if (!details.rule.getRuleDependencies().isEmpty()) {
                    StringBuilder message = new StringBuilder();
                    details.method.getDescriptor().describeTo(message);
                    message.append(" has dependencies on plugins: ");
                    message.append(details.rule.getRuleDependencies());

org.hamcrest.TypeSafeMatcher { void ResultMatchers$4(String); public boolean matchesSafely(PrintableResult); public void describeTo(org.hamcrest.Description); } org/junit/experimental/results/ResultMatchers$2.class package org.junit.experimental.results; final synchronized class ResultMatchers$2 extends org.hamcrest.BaseMatcher { void ResultMatchers$2(String); public boolean matches(Object); public void describeTo(org.hamcrest.Description); } org/junit/experimental/results/FailureList.class package org.junit.experimental.results;...