if !ok {
		return nil, nil, fmt.Errorf("not a node")
	}
	return labels.Set(nodeObj.ObjectMeta.Labels), NodeToSelectableFields(nodeObj), nil
}

// MatchNode returns a generic matcher for a given label and field selector.
func MatchNode(label labels.Selector, field fields.Selector) pkgstorage.SelectionPredicate {
	return pkgstorage.SelectionPredicate{
		Label:    label,
		Field:    field,
		GetAttrs: GetAttrs,

	store := &genericregistry.Store{
		NewFunc:                   func() runtime.Object { return &api.Node{} },
		NewListFunc:               func() runtime.Object { return &api.NodeList{} },
		PredicateFunc:             node.MatchNode,
		DefaultQualifiedResource:  api.Resource("nodes"),
		SingularQualifiedResource: api.Resource("node"),

		CreateStrategy:      node.Strategy,
		UpdateStrategy:      node.Strategy,

		true: {
			{"metadata.name": "foo"},
		},
		false: {
			{"foo": "bar"},
		},
	}

	for expectedResult, fieldSet := range testFieldMap {
		for _, field := range fieldSet {
			m := MatchNode(labels.Everything(), field.AsSelector())
			_, matchesSingle := m.MatchesSingle()
			if e, a := expectedResult, matchesSingle; e != a {
				t.Errorf("%+v: expected %v, got %v", fieldSet, e, a)
			}
		}
	}
}

        String nodeId
        String nodeType
        Predicate<NodeIdentity> identityPredicate
        List<String> dependencyNodeIds = []

        def matchNode(plannedNode) {
            plannedNode.nodeIdentity.nodeType.toString() == nodeType && identityPredicate.test(plannedNode.nodeIdentity)
        }

        @Override
        String toString() {

func AnnotateCRISocket(client clientset.Interface, nodeName string, criSocket string) error {

	klog.V(1).Infof("[patchnode] Uploading the CRI Socket information %q to the Node API object %q as an annotation\n", criSocket, nodeName)

	return apiclient.PatchNode(client, nodeName, func(n *v1.Node) {
		annotateNodeWithCRISocket(n, criSocket)
	})
}

func annotateNodeWithCRISocket(n *v1.Node, criSocket string) {

 * limitations under the License.
 */

package org.gradle.internal.watch.registry;

import org.slf4j.Logger;
import org.slf4j.helpers.NOPLogger;

public enum WatchMode {
    ENABLED(true, "enabled") {
        @Override
        public Logger loggerForWarnings(Logger currentLogger) {
            return currentLogger;
        }
    },
    DEFAULT(true, "enabled if available") {

        watchingVirtualFileSystem.afterBuildStarted(WatchMode.ENABLED, VfsLogging.NORMAL, WatchLogging.NORMAL, buildOperationRunner)
        then:
        1 * watcherRegistry.updateVfsOnBuildStarted(_ as SnapshotHierarchy, WatchMode.ENABLED, []) >> { SnapshotHierarchy root, watchMode, unsupportedFileSystems -> root }

        WatchMode.DEFAULT  | VfsLogging.NORMAL  | WatchLogging.DEBUG  | true
        WatchMode.ENABLED  | VfsLogging.VERBOSE | WatchLogging.NORMAL | true
        WatchMode.ENABLED  | VfsLogging.NORMAL  | WatchLogging.NORMAL | true
        WatchMode.ENABLED  | VfsLogging.VERBOSE | WatchLogging.DEBUG  | true
        WatchMode.ENABLED  | VfsLogging.NORMAL  | WatchLogging.DEBUG  | true

            gradle.startParameter.setWatchFileSystemMode(${WatchMode.name}.${watchMode.name()})
        """

        when:
        run("assemble", "--info")
        then:
        outputContains(ENABLED_IF_AVAILABLE_MESSAGE)
        outputContains(ACTIVE_MESSAGE)

        where:
        watchMode << WatchMode.values()
    }

            ));
        }
    }

    @Override
    public boolean afterBuildStarted(
        WatchMode watchMode,
        VfsLogging vfsLogging,
        WatchLogging watchLogging,
        BuildOperationRunner buildOperationRunner
    ) {
        warningLogger = watchMode.loggerForWarnings(LOGGER);
        stateInvalidatedAtStartOfBuild = false;
        reasonForNotWatchingFiles = null;