for i := 0; i < consume; i++ {
		if _, ok := evs.Pop(); !ok {
			t.Fatalf("iteration failed after %d events", i)
		}
	}

	if evs.buckets[0] != nil {
		t.Fatalf("expected first bucket to have been dropped")
	}
	for i, b := range evs.buckets[1:] {
		if b == nil {
			t.Fatalf("expected bucket %d to be non-nil", i+1)
		}
	}

	if n := evs.Len(); n != N-consume {

		prevNames := c.getReferencedObjects(prev)
		// Add new references
		for name := range names {
			if !prevNames.Has(name) {
				c.objectStore.AddReference(pod.Namespace, name, pod.UID)
			}
		}
		// Remove dropped references
		for prevName := range prevNames {
			if !names.Has(prevName) {
				c.objectStore.DeleteReference(pod.Namespace, prevName, pod.UID)
			}
		}
	}
}

//
// The size classes are chosen so that rounding an allocation
// request up to the next size class wastes at most 12.5% (1.125x).
//
// Each size class has its own page count that gets allocated
// and chopped up when new objects of the size class are needed.
// That page count is chosen so that chopping up the run of
// pages into objects of the given size wastes at most 12.5% (1.125x)

	s.pop(n.Pos())
	*s = append((*s), n)
}

// pop pops all nodes that appear lexically before pos
// (i.e., whose lexical extent has ended before or at pos).
// It returns the last node popped.
func (s *nodeStack) pop(pos token.Pos) (top Node) {
	i := len(*s)
	for i > 0 && (*s)[i-1].End() <= pos {
		top = (*s)[i-1]
		i--
	}
	*s = (*s)[0:i]
	return top
}