binaries.afterEach(new Action<TestSuiteBinarySpec>() {
                @Override
                public void execute(TestSuiteBinarySpec testSuiteBinary) {
                    if (testSuiteBinary.isBuildable()) {
                        if (testSuiteBinary.getTasks() instanceof TestSuiteTaskCollection) {
                            testSuiteBinary.checkedBy(((TestSuiteTaskCollection) testSuiteBinary.getTasks()).getRun());

            VariantComponentSpec variantComponentSpec = (VariantComponentSpec) componentSpec;
            buildable = variantComponentSpec.getBinaries().values().stream().anyMatch(BinarySpec::isBuildable);
        }
        return new DependentComponentsRenderableDependency(id, name, description, buildable, false, children);
    }

        when:
        result.isAvailable() >> true

        then:
        ability.isBuildable()
    }

    def "is not buildable when tool search is not successful" () {
        when:
        result.isAvailable() >> false

        then:
        !ability.isBuildable()
    }

    def "explains reason when tool search is not successful" () {
        def visitor = Mock(DiagnosticsVisitor)

        return vsProject;
    }

    @Optional
    @Input
    public String getBinaryOutputPath() {
        if (isBuildable()) {
            return binary.getOutputFile().getAbsolutePath();
        }
        return null;
    }

    @Input
    public boolean isBuildable() {
        return binary != null;
    }

    }

    @Override
    public void render(BinarySpec binary, TextReportBuilder builder) {
        String heading = StringUtils.capitalize(binary.getDisplayName());
        if (!binary.isBuildable()) {
            heading += " (not buildable)";
        }
        builder.heading(heading);

        if (binary.getBuildTask() != null) {
            builder.item("build using task", binary.getBuildTask().getPath());

 */
public interface DependentBinariesResolvedResult {

    LibraryBinaryIdentifier getId();

    String getProjectScopedName();

    boolean isBuildable();

    boolean isTestSuite();

    List<DependentBinariesResolvedResult> getChildren();

                if (dep.isTestSuite()) {
                    output.withStyle(Info).text(" (t)");
                    seenTestSuite = true;
                }
                if (!dep.isBuildable()) {
                    output.withStyle(Info).text(" NOT BUILDABLE");
                }
            }
        }
    }

    private static class ShowDependentPredicate implements Predicate<RenderableDependency> {

 * limitations under the License.
 */

package org.gradle.platform.base.internal;

import org.gradle.internal.logging.text.DiagnosticsVisitor;

public interface BinaryBuildAbility {
    boolean isBuildable();
    void explain(DiagnosticsVisitor visitor);

    private final boolean buildable;

    public FixedBuildAbility(boolean buildable) {
        this.buildable = buildable;
    }

    @Override
    public boolean isBuildable() {
        return buildable;
    }

    @Override
    public void explain(DiagnosticsVisitor visitor) {
        if (!buildable) {
            visitor.node("Disabled by user");
        }
    }

    final ToolSearchResult result;

    public ToolSearchBuildAbility(ToolSearchResult result) {
        this.result = result;
    }

    @Override
    public boolean isBuildable() {
        return result.isAvailable();
    }

    @Override
    public void explain(DiagnosticsVisitor visitor) {
        result.explain(visitor);
    }