}

    def "hide non-buildable dependents by default #nonBuildables"() {
        given:
        buildScript simpleCppBuild()
        nonBuildables.each { nonBuildable ->
            buildFile << """
                model {
                    components {
                        $nonBuildable {
                            binaries.all {
                                buildable = false
                            }

        return getIdentifier().getProjectScopedName();
    }

    @Override
    public void setBuildable(boolean buildable) {
        this.disabled = !buildable;
    }

    @Override
    public final boolean isBuildable() {
        return getBuildAbility().isBuildable();
    }

    @Override
    public DomainObjectSet<LanguageSourceSet> getInputs() {
        return inputSourceSets;
    }

    }

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

        withLibBinaries("notBuildableBinary1", "notBuildableBinary2")
        withStandaloneBinaries("ignoreMe")

        when:
        fails "assemble"

        then:
        failureDescriptionContains("Execution failed for task ':assemble'.")
        failure.assertHasCause("""No buildable binaries found:
  - SampleBinary 'lib:notBuildableBinary1':

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

        }

        private boolean isConfigurable() {
            return HasConfigurableValue.class.isAssignableFrom(declaredType);
        }

        private boolean isBuildable() {
            return Buildable.class.isAssignableFrom(declaredType);
        }

        @Nullable
        @Override
        public Object call() {
            return cachedInvoker.get();
        }
    }

            }
            if (hiddenNonBuildable) {
                output.withStyle(Info).println("Some non-buildable components were not shown, use --non-buildable or --all to show them.");
            }
        }
    }

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

            projectFile.addHeaderFile(headerFile);
        }

        if (vsProject.getConfigurations().stream().noneMatch(it -> it.isBuildable())) {
            getLogger().warn("'" + vsProject.getComponentName() + "' component in project '" + getProject().getPath() + "' is not buildable.");
        }
        for (VisualStudioProjectConfiguration configuration : vsProject.getConfigurations()) {

        }

        boolean isBuildable() { true }

        int getTime() { 0 }
    }

    def "properties are extracted from unmanaged type"() {
        when:
        def schema = extract(SimpleUnmanagedTypeWithAnnotations)

        then:
        assert schema instanceof UnmanagedImplStructSchema
        schema.properties*.name == ["buildable", "time", "unmanagedCalculatedProp", "unmanagedProp"]