for (NodeState node : nodes) {
            if (node.isSelected()) {
                consumer.accept(node);
            }
        }
    }

    @Override
    public List<ComponentState> getDependents() {
        List<ComponentState> incoming = Lists.newArrayListWithCapacity(nodes.size());
        for (NodeState node : nodes) {

        });
        selectorState.update(dependencyState);
        return selectorState;
    }

    @Nullable
    public NodeState peek() {
        return queue.isEmpty() ? null : queue.getFirst();
    }

    public NodeState pop() {
        NodeState next = queue.removeFirst();
        return next.dequeue();
    }

    /**

        return pendingDependencies;
    }

    void registerConstraintProvider(NodeState node) {
        pendingDependencies.registerConstraintProvider(node);
    }

    void unregisterConstraintProvider(NodeState nodeState) {
        pendingDependencies.unregisterConstraintProvider(nodeState);
    }

    public void maybeUpdateSelection(ResolutionConflictTracker conflictTracker) {

     */
    boolean hasSeenCapability(Capability capability);

    interface Candidate {
        NodeState getNode();
        Capability getCapability();
        Collection<NodeState> getImplicitCapabilityProviders();
    }

    interface ResolutionDetails extends ConflictResolutionResult {
        Collection<? extends Capability> getCapabilityVersions();

				}}),
				nodeWithTaints("nodeB", []v1.Taint{{
					Key:    "foo",
					Value:  "blah",
					Effect: v1.TaintEffectPreferNoSchedule,
				}}),
			},
			expectedList: []framework.NodeScore{
				{Name: "nodeA", Score: framework.MaxNodeScore},
				{Name: "nodeB", Score: 0},
			},
		},
		// the count of taints that are tolerated by pod, does not matter.
		{

    private collectOwnStrictVersions(NodeState node, List<String> children) {
        Set<ModuleIdentifier> constraintsSet = []
        for (String child : children) {
            node.maybeCollectStrictVersions(constraintsSet, edge(node, true, child, nextNode(), true).dependencyState)
        }
        node.storeOwnStrictVersions(constraintsSet)
    }

        private final VirtualPlatformState platformState;
        private final NodeState from;
        private final ComponentIdentifier platformId;

        public LenientPlatformConfigurationMetadata(VirtualPlatformState platform, ModuleComponentIdentifier componentId, NodeState from, @Nullable ComponentIdentifier platformId) {

        }
    }

    NodeState node(ComponentState cs) {
        def metadata = Mock(VariantGraphResolveMetadata) {
            getDependencies() >> []
            getCapabilities() >> ImmutableCapabilities.of([])
        }
        def state = Mock(VariantGraphResolveState) {
            getMetadata() >> metadata
        }

        def node = new NodeState(id++, cs, resolveState, state, true) {

	pod1, _ := newPod(t, "p1")
	pod1.DeletionTimestamp = &metav1.Time{Time: dc.clock.Now()}
	pod2, _ := newPod(t, "p2")
	pod3, _ := newPod(t, "p3")

	add(t, dc.podStore, pod1)
	add(t, dc.podStore, pod2)
	add(t, dc.podStore, pod3)

	dc.sync(ctx, pdbName)

	ps.VerifyPdbStatus(t, pdbName, 0, 1, 1, 3, map[string]metav1.Time{"p3": {Time: currentTime.Add(-time.Minute)}})
}

    .onlyIfCached()
    .maxStale(Int.MAX_VALUE.seconds)
    .build()

internal fun CacheControl.Builder.commonBuild(): CacheControl {
  return CacheControl(
    noCache = noCache,
    noStore = noStore,
    maxAgeSeconds = maxAgeSeconds,
    sMaxAgeSeconds = -1,
    isPrivate = false,
    isPublic = false,
    mustRevalidate = false,
    maxStaleSeconds = maxStaleSeconds,
    minFreshSeconds = minFreshSeconds,