}

	if n := evs.Len(); n != N {
		t.Fatalf("got %d events, want %d", n, N)
	}

	var n int
	evs.All()(func(ev *Event) bool {
		n++
		return true
	})
	if n != N {
		t.Fatalf("iterated over %d events, expected %d", n, N)
	}

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

}

// 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)
	}
}

        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"]

      signalPassFailure();
    }
  }

  // Remove all attr_map attributes.
  module_op.walk([](Operation* op) { op->removeAttr(kAttrMapAttribute); });

  // Perform selective quantization. Iterates over the quantization specs and
  // applies quantization methods to each matched lifted function.
  for (const QuantizationSpec& spec : quantization_specs_.specs()) {
    if (failed(ApplyQuantizationSpec(spec, module_op))) {

{!../../../docs_src/path_operation_advanced_configuration/tutorial001.py!}
```

### Using the *path operation function* name as the operationId

If you want to use your APIs' function names as `operationId`s, you can iterate over all of them and override each *path operation's* `operation_id` using their `APIRoute.name`.

You should do it after adding all your *path operations*.

```Python hl_lines="2  12-21  24"

	parentPc  int32 // position of an instruction whose source position is the call site (offset from entry)
	startLine int32 // line number of start of function (func keyword/TEXT directive)
}

// An inlineUnwinder iterates over the stack of inlined calls at a PC by
// decoding the inline table. The last step of iteration is always the frame of
// the physical function, so there's always at least one frame.
//
// This is typically used as:
//

- [All](/pkg/slices#All) returns an iterator over slice indexes and values.
- [Values](/pkg/slices#Values) returns an iterator over slice elements.
- [Backward](/pkg/slices#Backward) returns an iterator that loops over
  a slice backward.
- [Collect](/pkg/slices#Collect) collects values from an iterator into
  a new slice.
- [AppendSeq](/pkg/slices#AppendSeq) appends values from an iterator to
  an existing slice.

            }
        } else {
            Iterator<? extends Spec<? super T>> iterator = specs.iterator();
            if (!iterator.hasNext()) {
                this.specs = uncheckedCast(EMPTY);
            } else {
                this.specs = uncheckedCast(Iterators.toArray(iterator, Spec.class));
            }
        }
    }

        @Nonnull
        public Optional<Lifecycle> lookup(String id) {
            return getDelegate().lookup(id);
        }

        @Override
        public Iterator<Lifecycle> iterator() {
            return getDelegate().iterator();
        }

        protected LifecycleRegistry getDelegate() {
            return lifecycleRegistry;
        }
    }

        @Nonnull
        public Optional<Lifecycle> lookup(String id) {
            return getDelegate().lookup(id);
        }

        @Override
        public Iterator<Lifecycle> iterator() {
            return getDelegate().iterator();
        }

        protected LifecycleRegistry getDelegate() {
            return lifecycleRegistry;
        }
    }