return matcher.matches(string.replace(SystemProperties.getInstance().getLineSeparator(), "\n"));
            }

            @Override
            public void describeTo(Description description) {
                matcher.describeTo(description);
                description.appendText(" (normalize line separators)");
            }
        };
    }

 * limitations under the License.
 */

package org.gradle.model.internal.core.rule.describe;

import com.google.errorprone.annotations.FormatMethod;
import com.google.errorprone.annotations.FormatString;

/**
 * Describes a method rule.
 * All implementations of this class are expected to implement the equals and hashCode method
 */
public interface ModelRuleDescriptor {

        if (versionMatcher.matches(PlatformVersion)) {
          val description = StringDescription()
          versionMatcher.describeTo(description)
          description.appendText(" expected to fail with exception that ")
          failureMatcher.describeTo(description)

          fail<Any>(description.toString())
        }
      }
    }

        return append(String.format(child, args));
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        describeTo(sb);
        return sb.toString();
    }

    public UserAgentMatcher(String applicationName, String version) {
        this.applicationName = applicationName;
        this.version = version;
    }

    @Override
    public void describeTo(Description description) {
        description.appendValue(expectedUserAgentString());
    }

    @Factory
    public static UserAgentMatcher matchesNameAndVersion(String applicationName, String version) {

  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_;
};

        }
    }

    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

            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();

        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()) {

    protected static <T> Matcher<T> matching(Consumer<Description> describe, Predicate<T> match) {
        return new TypeSafeMatcher<T>() {
            @Override
            protected boolean matchesSafely(T item) {
                return match.test(item)
            }

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