}

// GetNode mocks base method.
func (m *MockProvider) GetNode() (*v10.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNode")
	ret0, _ := ret[0].(*v10.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNode indicates an expected call of GetNode.
func (mr *MockProviderMockRecorder) GetNode() *gomock.Call {
	mr.mock.ctrl.T.Helper()

    }

    def "querying for non-existing child #vfsSpec.searchedPath finds nothings (#vfsSpec)"() {
        setupTest(vfsSpec)

        when:
        def resultRoot = initialRoot.getNode(searchedPath, CASE_SENSITIVE)
        then:
        !resultRoot.present
        interaction { noMoreInteractions() }

        where:

	if kubeClient == nil {
		return nil
	}

	logger := klog.FromContext(ctx)
	logger = klog.LoggerWithName(logger, "node resources controller")
	ctx = klog.NewContext(ctx, logger)

	c := &nodeResourcesController{
		ctx:        ctx,
		kubeClient: kubeClient,
		getNode:    getNode,

		"/pods":    {cs: getContainerStats(), ns: getNetworkStats()},
	}

	mockCtrl := gomock.NewController(t)
	defer mockCtrl.Finish()
	mockStatsProvider := statstest.NewMockProvider(mockCtrl)

	mockStatsProvider.EXPECT().GetNode().Return(node, nil)
	mockStatsProvider.EXPECT().GetNodeConfig().Return(nodeConfig)
	mockStatsProvider.EXPECT().GetPodCgroupRoot().Return(cgroupRoot)
	mockStatsProvider.EXPECT().ListPodStats(ctx).Return(podStats, nil).AnyTimes()

        Collection<NodeState> implicitCapabilityProviders = candidate.getImplicitCapabilityProviders();
        nodes.addAll(implicitCapabilityProviders);
        NodeState node = candidate.getNode();
        if (nodes.add(node) && nodes.size() > 1) {
            // The registered nodes may contain nodes which are no longer selected.
            // We don't remove them from the list in the first place because it proved to be

	node, err := kvh.kubelet.GetNode()
	if err != nil {
		return nil, fmt.Errorf("error retrieving node: %v", err)
	}
	return node.Labels, nil
}

func (kvh *kubeletVolumeHost) GetAttachedVolumesFromNodeStatus() (map[v1.UniqueVolumeName]string, error) {
	node, err := kvh.kubelet.GetNode()
	if err != nil {
		return nil, fmt.Errorf("error retrieving node: %v", err)
	}

// getRuntime returns the current Runtime implementation in use by the kubelet.
func (kl *Kubelet) getRuntime() kubecontainer.Runtime {
	return kl.containerRuntime
}

// GetNode returns the node info for the configured node name of this Kubelet.
func (kl *Kubelet) GetNode() (*v1.Node, error) {
	if kl.kubeClient == nil {
		return kl.initialNode(context.TODO())
	}
	return kl.nodeLister.Get(string(kl.nodeName))
}

        return allRepositories.computeIfAbsent(repository, DefaultRemoteRepository::new);
    }

    @Override
    public Node getNode(org.eclipse.aether.graph.DependencyNode node) {
        return getNode(node, false);
    }

    @Override
    public Node getNode(org.eclipse.aether.graph.DependencyNode node, boolean verbose) {
        return allNodes.computeIfAbsent(node, n -> new DefaultNode(this, n, verbose));
    }

        ModelBinding subjectBinding = boundMutator.getSubjectBinding();
        final ModelNodeInternal node = subjectBinding.getNode();
        final ModelAction mutator = boundMutator.getAction();
        ModelRuleDescriptor descriptor = mutator.getDescriptor();

    public String getDisplayName() {
        return displayName;
    }

    @Override
    public QueryableExecutionPlan getContents() {
        return this;
    }

    @Override
    public TaskNode getNode(Task task) {
        return nodeMapping.get(task);
    }

    @Override
    public void setScheduledWork(ScheduledWork work) {
        if (scheduledNodes != null) {