assertTrue(reader.markSupported());

    assertEquals(string, readFully(reader));
    assertFullyRead(reader);

    // reset and read again
    reader.reset();
    assertEquals(string, readFully(reader));
    assertFullyRead(reader);

    // reset, skip, mark, then read the rest
    reader.reset();
    assertEquals(5, reader.skip(5));
    reader.mark(Integer.MAX_VALUE);
    assertEquals(string.substring(5), readFully(reader));

     * 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.

        }
    }

    @Test
    @DisplayName("Test reset method")
    void testReset() {
        // Given
        doNothing().when(messageBlock).reset();

        // When
        messageBlock.reset();

        // Then
        verify(messageBlock).reset();
    }

    @Test
    @DisplayName("Test multiple operations in sequence")

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

/**
 * Utility class for handling {@link File}.
 * <p>
 * <strong>SECURITY NOTE:</strong> When accepting file paths from untrusted sources,
 * always validate them using {@link #isPathSafe(Path, Path)} to prevent path traversal attacks.
 * Methods that accept path strings do not perform automatic validation to maintain backward compatibility.
 * </p>
 *
 * @author higa
 */
public abstract class FileUtil {

    /**

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

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

     */
    public static final int DELETE = 3;

    /**
     * Mode for viewing record details.
     */
    public static final int DETAILS = 4;

    /**
     * Protected constructor to prevent instantiation.
     */
    protected CrudMode() {
        // nothing
    }

    }

    /**
     * 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);