@Override
  protected void setUp() throws Exception {
    map = MutableClassToInstanceMap.create();
  }

  public void testConstraint() {
    /*
     * We'll give ourselves a pass on testing all the possible ways of breaking the constraint,
     * because we know that newClassMap() is implemented using ConstrainedMap which is itself

 * verify() method, which is called after each sequence and is guaranteed to be called
 * using the latest values obtained from {@link IteratorTester#newTargetIterator()}.
 *
 * <p>The value you pass to the parameter {@code steps} should be greater than the length of your
 * iterator, so that this class can check that your iterator behaves correctly when it is exhausted.
 *

    Map<K, V> delegateMap = Maps.newHashMapWithExpectedSize(n);
    // If duplicates are allowed, this map will track the last value for each duplicated key.
    // A second pass will retain only the first entry for that key, but with this last value. The
    // value will then be replaced by null, signaling that later entries with the same key should
    // be deleted.

// This base class does not expose any public methods other than to distinguish
// which subclass it actually is. The user is responsible to use the right
// type of AbstractTensor in their context (do not pass an MlirTensor to a
// GraphContext and vice-versa).
class TracingTensorHandle : public AbstractTensorHandle {
 protected:
  explicit TracingTensorHandle(AbstractTensorHandleKind kind)
      : AbstractTensorHandle(kind) {}

 * always very useful information.
 *
 * <p>On the other hand, a <i>parameter</i> type of {@link ImmutableList} is generally a nuisance to
 * callers. Instead, accept {@link Iterable} and have your method or constructor body pass it to the
 * appropriate {@code copyOf} method itself.
 *
 * <p>Expressing the immutability guarantee directly in the type that user code references is a

    Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          @Override
          public Integer computeNext() {
            throw exception;
          }
        };

    // It should pass through untouched
    SomeUncheckedException e = assertThrows(SomeUncheckedException.class, iter::hasNext);
    assertThat(e).isSameInstanceAs(exception);
  }

  public void testExceptionAfterEndOfData() {

    ):

        @app.websocket("/broken-scope")
        async def get_broken(
            websocket: WebSocket, sessions: BrokenSessionsDep
        ) -> Any:  # pragma: no cover
            pass


def test_named_function_scope() -> None:
    global_context.set({})
    global_state = global_context.get()
    with client.websocket_connect("/named-function-scope") as websocket:

    Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          @Override
          public Integer computeNext() {
            throw exception;
          }
        };

    // It should pass through untouched
    SomeUncheckedException e = assertThrows(SomeUncheckedException.class, iter::hasNext);
    assertThat(e).isSameInstanceAs(exception);
  }

  public void testExceptionAfterEndOfData() {

    Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          @Override
          public Integer computeNext() {
            throw exception;
          }
        };

    // It should pass through untouched
    SomeUncheckedException e = assertThrows(SomeUncheckedException.class, iter::hasNext);
    assertThat(e).isSameInstanceAs(exception);
  }

  public void testExceptionAfterEndOfData() {

### Contributing

We welcome contributions! Please:
1. Fork the repository
2. Create a feature branch
3. Make your changes with appropriate tests
4. Run `mvn clean test` to ensure all tests pass
5. Submit a pull request

### License