then:
        def root = ops.root(RunBuildBuildOperationType)

        def buildSrcOps = ops.all(BuildBuildSrcBuildOperationType)
        buildSrcOps.size() == 1
        buildSrcOps[0].displayName == "Build buildSrc"
        buildSrcOps[0].details.buildPath == ':'

        def loadOps = ops.all(LoadBuildBuildOperationType)
        loadOps.size() == 2
        loadOps[0].displayName == "Load build"

    }

    protected <T> T operation(Function<BuildOperationContext, T> operation, BuildOperationDescriptor.Builder description) {
        return buildOperationRunner.call(new CallableBuildOperation<T>() {
            @Override
            public T call(BuildOperationContext context) {
                return operation.apply(context);
            }

            @Override

/**
 * Fixes problem where main { } inside a closure is resolved as a call to static method main(). Does this by removing
 * the static method.
 */
public class FixMainScriptTransformer extends AbstractScriptTransformer {
    @Override
    protected int getPhase() {
        return Phases.CONVERSION;
    }

    @Override
    public void call(SourceUnit source) throws CompilationFailedException {

        return getTree().all(type, predicate)
    }

    @Override
    BuildOperationRecord first(Pattern displayName) {
        return getTree().first(displayName)
    }

    @Override
    List<BuildOperationRecord> all() {
        return getTree().all()
    }

    @Override

plugins {
    id 'objective-cpp'
}
// end::apply-plugin[]

// tag::executables[]
model {
    components {
        main(NativeExecutableSpec)
    }
}
// end::executables[]

// tag::all-binaries[]
model {
    binaries {
        all {
            //on macOS we need different linker settings than on Linux or Windows
            if (targetPlatform.operatingSystem.macOsX) {
                linker.args "-framework", "Foundation"

    }

    abstract BuildOperationRecord first(Pattern displayName)

    abstract List<BuildOperationRecord> all();

    List<BuildOperationRecord> all(String displayName) {
        return all(Pattern.compile(Pattern.quote(displayName)))
    }

    abstract List<BuildOperationRecord> all(Pattern displayName)

    BuildOperationRecord only(String displayName) {

    def "can create from classpath"() {
        when:
        def versions = new ReleasedVersionDistributions(IntegrationTestBuildContext.INSTANCE)

        then:
        !versions.all.empty
        versions.all*.version == versions.all*.version.sort().reverse()
    }

    def "get most recent final does that"() {
        when:
        props.mostRecent = "1.2"

        then:

    }

    @Override
    public ExecutionResult<Void> execute(BuildTreeWorkGraph.FinalizedGraph graph) {
        return buildOperationRunner.call(new CallableBuildOperation<ExecutionResult<Void>>() {
            @Override
            public ExecutionResult<Void> call(BuildOperationContext context) {
                return delegate.execute(graph);
            }

            @Override

    }

    public IncrementalCompilation processSourceFiles(final Collection<File> sourceFiles) {
        return buildOperationExecutor.call(new CallableBuildOperation<IncrementalCompilation>() {
            @Override
            public IncrementalCompilation call(BuildOperationContext context) {
                CompilationState previousCompileState = previousCompileStateCache.get();

    /**
     * Visits a node of the graph. Includes the root. This method is called for all nodes before {@link #visitEdges(DependencyGraphNode)} is called.
     */
    default void visitNode(DependencyGraphNode node) {}

    /**
     * Visits a selector. This method is called for all selectors before {@link #visitEdges(DependencyGraphNode)} is called.
     */