@Override
    public void ensureAtLeast(State state) {
        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;

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

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

    private static void assertNoProblemsSummary(String text) {

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

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

                allDiagnostics.add(details.source.healthDiagnostics());
            }
            for (WorkSource.Diagnostics diagnostics : allDiagnostics) {
                diagnostics.describeTo(formatter);
            }
        }
    }

    private static class ExecutorWorker implements Runnable {
        private final MergedQueues queue;
        private WorkerLease workerLease;

                    action.accept(failure);
                    return;
                }
            }
            StringDescription description = new StringDescription();
            matcher.describeTo(description);
            throw new AssertionFailedError(String.format("Could not find any failure with description %s, failures:%s\n", description, Joiner.on("\n").join(failures)));
        }

        @Override

 *
 * @param <FAILURE> the type of failure that this describer can describe
 */
public interface ResolutionFailureDescriber<FAILURE extends ResolutionFailure> {
    /**
     * Tests whether this describer can be applied to a given failure.
     *
     * This defaults to {@code true} as many describers are applicable to all instances of a single failure type

import org.gradle.internal.component.resolution.failure.describer.NoMatchingCapabilitiesFailureDescriber;
import org.gradle.internal.component.resolution.failure.describer.RequestedConfigurationNotFoundFailureDescriber;
import org.gradle.internal.component.resolution.failure.describer.ResolutionFailureDescriber;

     * Adds a {@link ResolutionFailureDescriber} for the given failure type to the custom describers
     * registered on this schema.
     *
     * If variant selection failures occur, these describers will be available to describe the failures.
     *
     * @param failureType The type of failure to describe
     * @param describerType A describer that can potentially describe failures of the given type
     * @param <FAILURE> The type of failure to describe