cache.ForceUpdateIfOlder(ctx, time.Now().Add(-20*time.Minute))
	actual := cache.GetCachedPods()
	comparePods(t, oldpods, actual)

	// A newer timestamp should force an update.
	cache.ForceUpdateIfOlder(ctx, time.Now().Add(20*time.Second))
	actual = cache.GetCachedPods()
	comparePods(t, newpods, actual)

}

// ComparePods compares actual pods with cached pods.
func (c *CacheComparer) ComparePods(pods, waitingPods []*v1.Pod, nodeinfos map[string]*framework.NodeInfo) (missed, redundant []string) {
	actual := []string{}
	for _, pod := range pods {
		actual = append(actual, string(pod.UID))
	}

	cached := []string{}
	for _, nodeinfo := range nodeinfos {
		for _, p := range nodeinfo.Pods {
			cached = append(cached, string(p.Pod.UID))

	for _, uid := range cached {
		pod := &v1.Pod{}
		pod.UID = types.UID(uid)
		pod.Namespace = "ns"
		pod.Name = uid

		nodeInfo[uid] = framework.NewNodeInfo(pod)
	}

	m, r := compare.ComparePods(pods, queuedPods, nodeInfo)

	if diff := cmp.Diff(missing, m); diff != "" {
		t.Errorf("Unexpected missing (-want, +got):\n%s", diff)
	}

	if diff := cmp.Diff(redundant, r); diff != "" {

		node        *api.Node
		oldNode     *api.Node
		compareNode *api.Node
	}{
		{
			name:        "nil pod cidrs",
			node:        makeNode(nil, false, false),
			oldNode:     nil,
			compareNode: makeNode(nil, false, false),
		},
		{
			name:        "empty pod ips",
			node:        makeNode([]string{}, false, false),
			oldNode:     nil,
			compareNode: makeNode([]string{}, false, false),
		},
		{

		log.Warnf("Failed to delete config (%+v): %v ", *c, err)
	}
}

// compareIDs compares the IDs (i.e. Namespace, GroupVersionKind, and Name) of the two configs and returns
// 0 if a == b, -1 if a < b, and 1 if a > b. Used for sorting config arrays.
func compareIDs(a, b *config.Config) int {
	return strings.Compare(a.Key(), b.Key())

				if iv, jv := l.Info.PrintableName(), r.Info.PrintableName(); iv != jv {
					return iv < jv
				}
				return compareNodes(l, r)
			},
		}
	case NameOrder:
		s = nodeSorter{ns,
			func(l, r *Node) bool {
				if iv, jv := l.Info.Name, r.Info.Name; iv != jv {
					return iv < jv
				}
				return compareNodes(l, r)
			},
		}
	case FileOrder:
		s = nodeSorter{ns,
			func(l, r *Node) bool {

type byKey []*config.Config

func (rs byKey) Len() int {
	return len(rs)
}

func (rs byKey) Swap(i, j int) {
	rs[i], rs[j] = rs[j], rs[i]
}

func (rs byKey) Less(i, j int) bool {
	return compareIDs(rs[i], rs[j]) < 0

                variants: variants,
                ignoreReasons: baseNode.ignoreReasons,
                ignoreReasonPrefixes: baseNode.ignoreReasonPrefixes)
        }
        compareNodes("components in graph", parseNodes(actualComponents), expectedComponents)

        def actualEdges = findLines(configDetails, 'dependency')