return new Predicate<MutableModelNode>() {
            @Override
            public boolean apply(MutableModelNode node) {
                node.ensureAtLeast(ModelNode.State.Discovered);
                return node.canBeViewedAs(type) && predicate.apply(node);
            }
        };
    }

            model {
                toolChains {
                    ${toolChain.buildScriptConfig}
                }
            }
        """
    }

    def "toolchain is not available when the discovered swift executable does not return sensible output"() {
        def scriptDir = testDirectory.createDir("scriptDir")
        def script = scriptDir.createFile("swiftc")
        script << """
            #!/bin/sh

        }

        doNotify(node);
        flush();
    }

    private void doAdd(ModelNodeInternal node) {
        flattened.put(node.getPath(), node);
        if (node.isAtLeast(ModelNode.State.Discovered)) {
            doNotify(node);
        }
    }

    private void doNotify(ModelNodeInternal node) {
        notifying = true;
        try {
            notifyListeners(node, pathListeners.get(node.getPath()));

        given:
        graph.addListener(listener)

        when:
        graph.add(a)

        then:
        0 * listener.onDiscovered(_)

        when:
        a.state = State.Discovered
        graph.nodeDiscovered(a)

        then:
        1 * listener.onDiscovered(a)
        0 * listener.onDiscovered(_)
    }

    def "notifies listener of new node with matching path"() {

	tagMatcher = regexp.MustCompile(`^(?U:.*)(?::([[:word:]][[:word:].-]*))?(?:@sha256:[a-fA-F\d]{64})?$`)
)

// TagFromImage extracts a tag from image. An empty string is returned if no tag is discovered.
func TagFromImage(image string) string {
	matches := tagMatcher.FindStringSubmatch(image)
	if len(matches) >= 2 {
		return matches[1]
	}
	return ""

import org.gradle.util.internal.TextUtil;

import static org.gradle.api.problems.Severity.ERROR;
import static org.gradle.internal.deprecation.Documentation.userManual;

/**
 * A handler for properties discovered without a valid annotation.
 */
public interface MissingPropertyAnnotationHandler {
    void handleMissingPropertyAnnotation(TypeValidationContext context, PropertyAnnotationMetadata annotationMetadata, String displayName);

     * that the output is generated in a stable order rather than in an order based on the order that implementations
     * are discovered.
     */
    String getId();

    /**
     * Notifies the build user of whatever problems have been collected. May report problems to the console, or generate a report

        registry.register(barRegistration)
        def foo = registry.atStateOrLater(fooReference.path, ModelNode.State.Discovered)

        then:
        !foo.promise.canBeViewedAs(ModelType.of(String))
        foo.promise.canBeViewedAs(ModelType.of(List))

        registry.realize(fooReference.path, fooReference.type).is(fooList)

  // Value: Information we know about that Value.
  // Note that these Value's are in general in different functions.
  DenseMap<Value, ResourceInfo> resource_infos_;
  // The set of regions we already discovered.
  DenseSet<Region*> discovered_;
  // Identifiers about mutable variables.
  // All variables are identified by (device, container, shared_name).
  DenseSet<std::tuple<llvm::StringRef, llvm::StringRef, llvm::StringRef>>

/**
 * A hard-coded sequence of model actions that can be applied to a model element.
 *
 * <p>This is pretty much a placeholder for something more descriptive.
 */
public enum ModelActionRole {
    Discover(ModelNode.State.Discovered, false), // Defines all projections for the node
    Create(ModelNode.State.Created, false), // Initializes the node
    Defaults(ModelNode.State.DefaultsApplied, true), // Allows a mutation to setup default values for an element