where:
        elements << [
            [],
            ["a"],
            ["a", "b", "c"],
            ["a", "b", "c", "d"]
        ]
    }

    def "iterator iterates the elements #elements"() {
        expect:
        ImmutableList.copyOf(listOf(elements)) == elements

        where:
        elements << [
            [],
            ["a"],
            ["a", "b", "c"],
            ["a", "b", "c", "d"]

limitations under the License.
*/

package genericclioptions

import (
	"k8s.io/cli-runtime/pkg/resource"
)

// NewSimpleFakeResourceFinder builds a super simple ResourceFinder that just iterates over the objects you provided
func NewSimpleFakeResourceFinder(infos ...*resource.Info) ResourceFinder {
	return &fakeResourceFinder{
		Infos: infos,
	}
}

type fakeResourceFinder struct {
	Infos []*resource.Info

import java.util.Collection;
import java.util.Iterator;

public interface ElementSource<T> extends Iterable<T>, WithEstimatedSize, PendingSource<T>, WithMutationGuard {
    /**
     * Iterates over and realizes each of the elements of this source.
     */
    @Override
    Iterator<T> iterator();

    /**
     * Iterates over only the realized elements (without flushing any pending elements)
     */

}

// get a WaitingPod from the map.
func (m *waitingPodsMap) get(uid types.UID) *waitingPod {
	m.mu.RLock()
	defer m.mu.RUnlock()
	return m.pods[uid]
}

// iterate acquires a read lock and iterates over the WaitingPods map.
func (m *waitingPodsMap) iterate(callback func(framework.WaitingPod)) {
	m.mu.RLock()
	defer m.mu.RUnlock()
	for _, v := range m.pods {
		callback(v)
	}
}

import java.util.Queue;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * An Iterator implementation which draws elements from a queue, removing them from the queue as it
 * iterates. This class is not thread safe.
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class ConsumingQueueIterator<T extends @Nullable Object> extends AbstractIterator<T> {

import java.util.Queue;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * An Iterator implementation which draws elements from a queue, removing them from the queue as it
 * iterates. This class is not thread safe.
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
final class ConsumingQueueIterator<T extends @Nullable Object> extends AbstractIterator<T> {

	// 2) workload instances have the same IP but different networks
	GetByIP(string) []*model.WorkloadInstance
	// Empty returns whether the index is empty.
	Empty() bool
	// ForEach iterates over all workload instances in the index.
	ForEach(func(*model.WorkloadInstance))
}

// indexKey returns index key for a given workload instance.
func indexKey(wi *model.WorkloadInstance) string {

	// Exists returns true if the specified resource exists in the context, false otherwise
	Exists(c config.GroupVersionKind, name resource.FullName) bool

	// ForEach iterates over all the entries of a given collection.
	ForEach(c config.GroupVersionKind, fn IteratorFn)

	// Canceled indicates that the context has been canceled. The analyzer should stop executing as soon as possible.
	Canceled() bool

		return
	}
	nt.removeNode(logger, old) // No error checking. We ignore whether the old node exists or not.
	nt.addNode(logger, new)
}

// list returns the list of names of the node. NodeTree iterates over zones and in each zone iterates
// over nodes in a round robin fashion.
func (nt *nodeTree) list() ([]string, error) {
	if len(nt.zones) == 0 {
		return nil, nil
	}
	nodesList := make([]string, 0, nt.numNodes)

       * documented in the Javadoc. If a row Comparator is provided, cellSet() iterates across the
       * columns in the first row, the columns in the second row, etc. If a column Comparator is
       * provided but a row Comparator isn't, cellSet() iterates across the rows in the first
       * column, the rows in the second column, etc.
       */
      Comparator<Cell<R, C, V>> comparator =