}

    def resolvesBuildable() {
        Buildable buildable = Mock()
        TaskDependency otherDependency = Mock()

        when:
        def tasks = context.getDependencies(task, dependency)

        then:
        1 * dependency.visitDependencies(_) >> { TaskDependencyResolveContext context -> context.add(buildable) }
        1 * buildable.getBuildDependencies() >> { otherDependency }

    public BuildableBackedProvider(Buildable buildable, Class<T> valueType, Factory<T> valueFactory) {
        this.buildable = buildable;
        this.valueType = valueType;
        this.valueFactory = valueFactory;
    }

    @Nullable
    @Override
    public Class<T> getType() {
        return valueType;
    }

    @Override
    public ValueProducer getProducer() {

class FixedBuildAbilityTest extends Specification {
    def "is buildable" () {
        when:
        def ability = new FixedBuildAbility(true)

        then:
        ability.buildable
    }

    def "is not buildable" () {
        when:
        def ability = new FixedBuildAbility(false)

        then:
        !ability.buildable
    }

    def "explains not buildable reason" () {
        def visitor = Mock(DiagnosticsVisitor)

            }
        };
    }

    @Factory
    public static <T extends Buildable> Matcher<T> builtBy(String... tasks) {
        return builtBy(equalTo(new HashSet<String>(Arrays.asList(tasks))));
    }

    @Factory
    public static <T extends Buildable> Matcher<T> builtBy(final Matcher<? extends Iterable<String>> matcher) {
        return new BaseMatcher<T>() {
            @Override

    }
}
// end::withArguments[]

model {
    components {
        main(NativeExecutableSpec)
    }
}

// tag::buildable[]
model {
    tasks {
        buildAllExecutables(Task) {
            dependsOn $.binaries.findAll { it.buildable }
        }
    }
}

                connectedNodes.addAll(queue);
                return;
            }
            if (node instanceof Buildable) {
                Buildable buildable = (Buildable) node;
                connectedNodes.add(buildable.getBuildDependencies());
                return;
            }
            for (WorkDependencyResolver<T> workResolver : workResolvers) {

Laura Kassovic <******@****.***> 1701107622 -0800

    }

    /**
     * Should this include non-buildable components in the report?
     */
    @Console
    public boolean isShowNonBuildable() {
        return showNonBuildable;
    }

    @Option(option = "non-buildable", description = "Show non-buildable components.")
    public void setShowNonBuildable(boolean showNonBuildable) {

        then:
        output.contains("Displays the dependent components of components in root project 'test'. [deprecated]")
        output.contains("--all     Show all components (non-buildable and test suites).")
        output.contains("--non-buildable     Show non-buildable components.")
        output.contains("--test-suites     Show test suites components.")

        1 * provider.get() >> 'ignore'
        result.empty
    }

    def "resolves task dependencies for provider with unknown producer and buildable value"() {
        def task = Stub(Task)
        def value = Mock(Buildable)

        when:
        def dependencies = fileCollection.buildDependencies

        then:
        0 * _

        when: