def "suggests model paths with Levenshtein distance lower than 4"() {
        when:
        availablePaths = ["task.afoobar", "tasks.boofar", "tasks.foobar", "tasks.f", "fooba"]

        then:
        suggestionsFor("tasks.fooba") == ["tasks.foobar", "task.afoobar", "tasks.boofar"]
    }

    def "suggests model paths with Levenshtein distance lower than half it's length for strings shorter than 6 characters"() {
        when:

        where:
        invalidOutput | fileName   | message
        'zipTree'     | 'some.jar' | "ZIP '%s'"
        'tarTree'     | 'some.tar' | "TAR '%s'"
    }

    def "task with base Java type input property can be up-to-date"() {
        buildFile << """
            class MyTask extends DefaultTask {
                @Input Duration duration

    }

    protected static boolean isRead(int unixNumeric) {
        return (unixNumeric & 4) >> 2 == 1;
    }

    protected static boolean isRead(String unixSymbolic) {
        char symbol = unixSymbolic.charAt(0);
        if (symbol == 'r') {
            return true;
        } else if (symbol == '-') {
            return false;
        } else {

@UnsupportedWithConfigurationCache(because = "software model")
class NestedModelRuleDslDetectionIntegrationTest extends AbstractIntegrationSpec {
    def "rules can contain arbitrary code that includes closures that look like nested rules"() {
        buildFile << '''
class UnmanagedThing {
    def getSomeProp() {
        return this
    }
    def conf(Closure cl) {
        cl.delegate = this
        cl.call()

            }
            return map;
        }

        public void nodeRemoved(ModelNodeInternal node) {
            // This could be more efficient; assume that removal happens much less often than addition
            for (ModelNode.State state : ModelNode.State.values()) {
                Map<String, List<RuleBinder>> byState = getByState(state);

        .put("tar.snappy", new SnappyPacker(new CommonsTarPacker(4)))
        .put("tar.snappy.commons", new SnappyCommonsPacker(new CommonsTarPacker(4)))
        .put("tar.snappy.dain", new SnappyDainPacker(new CommonsTarPacker(4)))
        .put("tar.snappy.small", new SnappyPacker(new CommonsTarPacker(2)))
        .put("tar.snappy.large", new SnappyPacker(new CommonsTarPacker(64)))

import org.gradle.model.internal.type.ModelType;

public interface ModelPromise {

    <T> boolean canBeViewedAs(ModelType<T> type);

    // These methods return strings rather than types because it may be more complicated than what is able to be expressed via a ModelType.

}

// Defines configurations used to resolve external dependencies
// that the public API depends on.
// TODO: We should be able to derive these dependencies automatically.
//       In fact, our public API should have no external dependencies.
val externalApi = configurations.dependencyScope("externalApi") {
    description = "External dependencies that the public Gradle API depends on"
}

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

/**
 * <p>A mapping provider that uses a transform for which {@link MappingProvider} cannot be used.
 * This implementation is used for user provided transforms and also for internal transforms that don't meet the constraints of {@link MappingProvider}.</p>
 *
 * <p>This provider checks that the contents of value have been built prior to running the transform, as the transform may use the content.

            }
            if (!(o instanceof Map.Entry)) {
                return false;
            }
            Map.Entry<?, ?> that = (Map.Entry<?, ?>) o;
            return Objects.equals(delegate.getKey(), that.getKey()) && Objects.equals(delegate.getValue(), that.getValue());
        }

        @Override
        public int hashCode() {
            return delegate.hashCode();
        }