assertEquals('D', stream.read());

            // Reset will throw IOException because mark is not supported
            try {
                stream.reset();
                fail("reset() should throw IOException when mark is not supported");
            } catch (IOException e) {
                // Expected - FileInputStream does not support mark/reset
            }
        }
    }

    }

    @Test
    @DisplayName("Test reset functionality")
    void testReset() {
        // Reset should not throw exception
        assertDoesNotThrow(() -> transaction.reset());

        // Transaction should be ready for reuse
        assertTrue(transaction.hasMoreElements());
    }

    @Test
    @DisplayName("Test reset with key and lastName")
    void testResetWithKeyAndLastName() {

     * This method delegates to {@link FileInputStream#reset()}.
     *
     * @throws IOException if an I/O error occurs.
     */
    @Override
    public synchronized void reset() throws IOException {
        fileInputStream.reset();
    }

    /**
     * Skips over and discards {@code n} bytes of data from this input stream.

    public synchronized void mark(final int readlimit) {
        inputStream.mark(readlimit);
    }

    /**
     * Tests if this input stream supports the mark and reset methods.
     *
     * @return true if this stream instance supports the mark and reset methods; false otherwise
     */
    @Override
    public boolean markSupported() {
        return inputStream.markSupported();
    }

    /**

            searchPaging(data, form);
        });
    }

    /**
     * Reset search criteria and return to default view.
     *
     * @param form the search form to reset
     * @return HTML response for the reset page
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse reset(final SearchForm form) {
        validate(form, messages -> {}, this::asDictIndexHtml);

    /**
     * Resets the {@link InputStream}.
     *
     * @param is the input stream (must not be {@literal null})
     * @see InputStream#reset()
     */
    public static void reset(final InputStream is) {
        assertArgumentNotNull("is", is);

        try {
            is.reset();
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

      }
    }
    out.close();

    // Check that source returns the right data
    assertThat(source.read()).isEqualTo(data);

    // Make sure that reset deleted the file
    out.reset();
    if (file != null) {
      assertFalse(file.exists());
    }
  }


  public void testThreshold_resetOnFinalize() throws Exception {
    testThreshold(0, 100, true, true);

    }

    /**
     * Test that pre-auth hash is reset on error
     */
    @Test
    @DisplayName("Pre-auth integrity hash should reset on error")
    void testPreauthHashResetOnError() throws Exception {
        // Setup invalid SMB2 state to trigger error
        setPrivateField(transport, "smb2", false);

        // Try to update preauth hash - should fail and reset

    }

    @Test
    void testResetAndReuse() {
        // Test that HMACT64 can be reset and reused
        HMACT64 hmac = new HMACT64(TEST_KEY);

        // First use
        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);
        byte[] result1 = hmac.engineDigest();

        // Reset and reuse with same data
        hmac.engineReset();
        hmac.engineUpdate(TEST_DATA, 0, TEST_DATA.length);

async def set_up_request_state_dependency():
    request_state = {"user": "deadpond"}
    contextvar_token = legacy_request_state_context_var.set(request_state)
    yield request_state
    legacy_request_state_context_var.reset(contextvar_token)


@app.middleware("http")
async def custom_middleware(
    request: Request, call_next: Callable[[Request], Awaitable[Response]]
):
    response = await call_next(request)