return register(modelRegistry, ModelPath.path(path), definition);
    }

    public static ModelRegistry register(ModelRegistry modelRegistry, ModelPath path, Transformer<? extends ModelRegistration, ? super ModelRegistrations.Builder> definition) {

     * modifications don't affect future retrievals of the super POM.
     *
     * @param version The model version to retrieve the super POM for (e.g. "4.0.0"), must not be {@code null}.
     * @return The super POM, never {@code null}.
     */
    Model getSuperModel(String version);

        super(GradleVersion.version(version), versionDir.file("gradle-$version"), versionDir.file("gradle-$version-bin.zip"))
        this.versionDir = versionDir
    }

    TestFile getBinDistribution() {
        downloadIfNecessary()
        super.getBinDistribution()
    }

    TestFile getGradleHomeDir() {
        downloadIfNecessary()
        super.getGradleHomeDir()
    }

        all(ConfigureUtil.configureUsing(action));
    }

    @Override
    public void configureEach(Action<? super T> action) {
        delegate.configureEach(action);
    }

    @Override
    public Action<? super T> whenObjectAdded(Action<? super T> action) {
        return delegate.whenObjectAdded(action);
    }

    @Override
    public void whenObjectAdded(Closure action) {

        super(type, instantiator, callbackActionDecorator);
        nameDescription = type.getSimpleName() + " name";
    }

    @Override
    public T create(String name, Action<? super T> configureAction) throws InvalidUserDataException {
        NameValidator.validate(name, nameDescription, "");
        return super.create(name, configureAction);
    }

  }

  TreeMultimap(Comparator<? super K> keyComparator, Comparator<? super V> valueComparator) {
    super(new TreeMap<K, Collection<V>>(keyComparator));
    this.keyComparator = keyComparator;
    this.valueComparator = valueComparator;
  }

  private TreeMultimap(
      Comparator<? super K> keyComparator,
      Comparator<? super V> valueComparator,
      Multimap<? extends K, ? extends V> multimap) {

    log("appendingSink($file)")

    return super.appendingSink(file, mustExist)
  }

  override fun atomicMove(
    source: Path,
    target: Path,
  ) {
    log("atomicMove($source, $target)")

    super.atomicMove(source, target)
  }

  override fun createDirectory(
    dir: Path,
    mustCreate: Boolean,
  ) {
    log("createDirectory($dir)")

    super.createDirectory(dir, mustCreate)
  }

public class HttpCallException extends RuntimeException {

    public HttpCallException(String message) {
        super(message);
    }

    public HttpCallException(String message, Throwable cause) {
        super(message, cause);
    }

    public HttpCallException(Throwable cause) {
        super(cause);
    }

      extends AbstractCatchingFuture<V, X, Function<? super X, ? extends V>, V> {
    CatchingFuture(
        ListenableFuture<? extends V> input,
        Class<X> exceptionType,
        Function<? super X, ? extends V> fallback) {
      super(input, exceptionType, fallback);
    }

    @Override
    @ParametricNullness
    V doFallback(Function<? super X, ? extends V> fallback, X cause) throws Exception {

    if (deleteFaults.contains(fileOrDirectory)) throw IOException("boom!")
    super.deleteRecursively(fileOrDirectory, mustExist)
  }

  override fun appendingSink(
    file: Path,
    mustExist: Boolean,
  ): Sink = FaultySink(super.appendingSink(file, mustExist), file)

  override fun sink(
    file: Path,
    mustCreate: Boolean,
  ): Sink = FaultySink(super.sink(file, mustCreate), file)