@Override
                protected BinaryBuildAbility getBinaryBuildAbility() {
                    return new BinaryBuildAbility() {
                        @Override
                        public boolean isBuildable() {
                            return ! getName().contains("notBuildable");
                        }

                        @Override
                        public void explain(${DiagnosticsVisitor.name} visitor) {

                getCompilerDefines() >> defines
                getIncludePaths() >> includes.collect { file(it) }
                getOutputFile() >> new File("out")
            }
            isBuildable() >> true
        }
    }

    private ProjectFile getProjectFile() {
        def file = testDirectoryProvider.testDirectory.file("project.xml")
        generator.store(file)

        ComponentSpecInternal internalProtocol = (ComponentSpecInternal) component;
        DependentComponentsRenderableDependency root = getRenderableDependencyOf(component, internalProtocol);
        if (!showNonBuildable && !root.isBuildable()) {
            hiddenNonBuildable = true;
            return;
        }
        StyledTextOutput output = builder.getOutput();
        GraphRenderer renderer = new GraphRenderer(output);

        }

        for (File headerFile : vsProject.getHeaderFiles()) {
            projectFile.addHeaderFile(headerFile);
        }

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

                        for (DependentBinariesResolvedResult dependent : result.getChildren()) {
                            if (dependent.isBuildable() && dependent.isTestSuite()) {
                                ModelRegistry modelRegistry = projectModelResolver.resolveProjectModel(dependent.getId().getProjectPath());

        DependentBinariesResolvedResult result = dependentsResolver.resolve(binary).getRoot();
        for (DependentBinariesResolvedResult dependent : result.getChildren()) {
            if (dependent.isBuildable()) {
                ModelRegistry modelRegistry = projectModelResolver.resolveProjectModel(dependent.getId().getProjectPath());

            List<DependentBinariesResolvedResult> children = doBuildResolvedResult(dependent, state, stack);
            result.add(new DefaultDependentBinariesResolvedResult(dependent.getId(), dependent.getProjectScopedName(), dependent.isBuildable(), isTestSuite(dependent), children));
        }
        stack.pop();
        resultsCache.put(target, result);
        return result;
    }

        @CustomTestAnnotation("unmanagedCalculated")
        String getUnmanagedCalculatedProp() {
            return "unmanaged-calculated"
        }

        boolean isBuildable() { true }

        int getTime() { 0 }
    }

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

                for (BinarySpecInternal binary : component.getBinaries().withType(BinarySpecInternal.class)) {
                    if (binary.isBuildable()) {
                        assemble.dependsOn(binary);
                        hasBuildableBinaries = true;
                    } else {
                        notBuildable.add(binary);
                    }

        addToGroup(project.getMainGroup(), xcodeProject.getGroups().getRoot());

        for (XcodeTarget xcodeTarget : xcodeProject.getTargets()) {
            if (xcodeTarget.isBuildable()) {
                project.getTargets().add(toGradlePbxTarget(xcodeTarget));
            } else {
                getLogger().warn("'" + xcodeTarget.getName() + "' component in project '" + projectPath + "' is not buildable.");