/**
   * Returns the subgraph of {@code graph} induced by {@code nodes}. This subgraph is a new graph
   * that contains all of the nodes in {@code nodes}, and all of the {@link Graph#edges() edges}
   * from {@code graph} for which both nodes are contained by {@code nodes}.
   *
   * @throws IllegalArgumentException if any element in {@code nodes} is not a node in the graph
   */

						12,
						12,
					},
				},
			},
			expectedNUMAInfo: &NUMAInfo{
				Nodes: []int{0},
				NUMADistances: NUMADistances{
					0: {
						10,
						11,
						12,
						12,
					},
				},
			},
			opts: PolicyOptions{
				PreferClosestNUMA: true,
			},
		},
		{
			name: "positive test 2 nodes",
			topology: []cadvisorapi.Node{
				{
					Id: 0,
				},
				{
					Id: 1,

// sockets contain a bigger number of CPUs (free and busy) than NUMA nodes, or equivalently that each
// socket contains more than one NUMA node.
//
// If instead sockets are lower in the memory hierarchy than NUMA nodes, they are sorted as follows.
// First, they are sorted by number of free CPUs in the NUMA nodes that contain them. Then, for each

            nodes[1].nodeDependencies*.name == []
            nodes[2].nodeIdentity.name == "task3"
            nodes[2].nodeDependencies*.name == []
            nodes[3].nodeIdentity.name == "task4"
            nodes[3].nodeDependencies*.name == ["transformStep2"]
            nodes[4].nodeIdentity.name == "transformStep1"
            nodes[4].nodeDependencies*.name == ["task2", "task3"]

		// But there are more nodes(actually more existing pods) in regionChina that match the preference than regionIndia.
		// Then, nodes in regionChina get higher score than nodes in regionIndia, and all the nodes in regionChina should get a same score(high score),
		// while all the nodes in regionIndia should get another same score(low score).
		{

        def modules1 = endorseFrom1.targetComponent.nodes[0].ownStrictVersionConstraints.getModules()
        def modules2 = endorseFrom2.targetComponent.nodes[0].ownStrictVersionConstraints.getModules()

        modulesAll.size() == 5
        modules1.size() == 1
        modules2.size() == 4

        modulesAll == modules1 + modules2

        endorseFrom1.targetComponent.nodes[0].ownStrictVersionConstraints != endorsedStrictVersions

			return err
		}
		if len(nodes) < absDelta {
			return fmt.Errorf("can't remove %d nodes from %s nodegroup, not enough nodes: %d", absDelta, nodeGroup, len(nodes))
		}
		for i, node := range nodes {
			if i == absDelta {
				return nil
			}
			if err := kubemarkController.RemoveNodeFromNodeGroup(nodeGroup, node); err != nil {
				return err
			}
		}
	case delta > 0:

	for k, v := range cache.nodes {
		nodes[k] = v.info.Snapshot()
	}

	return &Dump{
		Nodes:       nodes,
		AssumedPods: cache.assumedPods.Union(nil),
	}
}

// UpdateSnapshot takes a snapshot of cached NodeInfo map. This is called at
// beginning of every scheduling cycle.
// The snapshot only includes Nodes that are not deleted at the time this function is called.

        final Set<NodeState> nodes = findNodesFor(capability);
        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.

    };
  }

  /**
   * Returns an unmodifiable {@code Iterable} over the nodes reachable from {@code startNode}, in
   * the order of a breadth-first traversal. That is, all the nodes of depth 0 are returned, then
   * depth 1, then 2, and so on.
   *
   * <p><b>Example:</b> The following graph with {@code startNode} {@code a} would return nodes in
   * the order {@code abcdef} (assuming successors are returned in alphabetical order).