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

        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.")

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

    }

    /**
     * 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) {

            taskDependency.getDependencies(task);
    }

    public static Set<? extends Task> getDependenciesForInternalUse(Buildable buildable) {
        return getDependenciesForInternalUse(buildable.getBuildDependencies(), null);
    }

        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:

                    NMakeBuildCommandLine("echo '${configuration.project.name}' project is not buildable. && exit /b -42")
                    NMakeCleanCommandLine("echo '${configuration.project.name}' project is not buildable. && exit /b -42")
                    NMakeReBuildCommandLine("echo '${configuration.project.name}' project is not buildable. && exit /b -42")
                }
            }
        }

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

        when:
        fails "assemble"

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