rcfg:         replicationConfig{Config: &configs[0]},
		expectedSync: false,
	},
	{ // 4. existing object replication enabled, versioning enabled; no reset in progress
		name: "existing object replication enabled, versioning enabled; no reset in progress",
		info: ObjectInfo{
			Size:              100,
			ReplicationStatus: replication.Completed,
			VersionID:         "a3348c34-c352-4498-82f0-1098e8b34df9",
		},

        // Reset error and test hasMore flag
        response.setTestErrorCode(0);
        response.hasMore = false;
        assertFalse(response.hasMoreElements());
    }

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

    @Test

        buf.reset();
        ns.encode(buf); // should not throw

        // After encoding, check how many bytes were used
        int bytesUsed = buf.getIndex();
        // Should be 2 bytes for the short value (alignment may add padding)
        assertTrue(bytesUsed >= 2, "Should use at least 2 bytes for short");

        // Reset index to read back
        buf.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() {

	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeallTierStats Msgsize() is inaccurate")
	}

	vn := allTierStats{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeallTierStats(b *testing.B) {
	v := allTierStats{}
	var buf bytes.Buffer

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

		t.Log("WARNING: TestEncodeDecodeBatchJobReplicateCredentials Msgsize() is inaccurate")
	}

	vn := BatchJobReplicateCredentials{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeBatchJobReplicateCredentials(b *testing.B) {
	v := BatchJobReplicateCredentials{}

        assertTrue(statsBefore.get(EventType.FILE_ACCESS) > 0, "Should have file access events before reset");

        logger.resetStatistics();

        Map<EventType, Long> statsAfter = logger.getStatistics();
        // After reset, all counters should be 0
        for (Long count : statsAfter.values()) {

  @Override
  public void mark(int readlimit) {}

  /**
   * reset() is not supported for HashingInputStream.
   *
   * @throws IOException this operation is not supported
   */
  @Override
  public void reset() throws IOException {
    throw new IOException("reset not supported");
  }

  /**

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

    /**