assertEquals("real-artifact", project.getArtifactId(), "artifactId is masked.");
        assertEquals("1000", project.getVersion(), "version proto-inheritance failed.");

        // draw the NPE.
        project.getId();
    }

    @Test
    void testEmptyConstructor() {
        MavenProject project = new MavenProject();

        assertEquals(

Jinzhu <******@****.***> 1748158840 +0800

        int type = AvPair.MsvAvTimestamp;
        byte[] raw = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        AvPair avPair = new AvPair(type, raw);

        // Modify the original raw array
        raw[0] = 0x05;

        // Ensure the AvPair's internal raw array is not affected (defensive copy not made)
        // This test assumes that the AvPair constructor does NOT make a defensive copy of the raw array.

        return switch (avId) {
        case AvPair.MsvAvFlags -> new AvFlags(raw);
        case AvPair.MsvAvTimestamp -> new AvTimestamp(raw);
        case AvPair.MsvAvTargetName -> new AvTargetName(raw);
        case AvPair.MsvAvSingleHost -> new AvSingleHost(raw);
        case AvPair.MsvAvChannelBindings -> new AvChannelBindings(raw);
        default -> new AvPair(avId, raw);

    private final int type;
    private final byte[] raw;

    /**
     * Constructs an AV pair with type and raw data
     * @param type the AV pair type
     * @param raw the raw data bytes
     */
    public AvPair(final int type, final byte[] raw) {
        this.type = type;
        this.raw = raw;
    }

    /**
     * Gets the AV pair type
     * @return the type
     */

	case ChecksumCRC32C:
		v := crc32Combine(crc32.Castagnoli, binary.BigEndian.Uint32(c.Raw), binary.BigEndian.Uint32(other.Raw), size)
		binary.BigEndian.PutUint32(c.Raw, v)
	case ChecksumCRC64NVME:
		v := crc64Combine(bits.Reverse64(crc64NVMEPolynomial), binary.BigEndian.Uint64(c.Raw), binary.BigEndian.Uint64(other.Raw), size)
		binary.BigEndian.PutUint64(c.Raw, v)
	default:
		return fmt.Errorf("unknown checksum type: %s", c.Type.String())

 *
 * @author mbechler
 */
public class AvFlags extends AvPair {

    /**
     * Constructs an AV flags pair from raw bytes
     * @param raw the raw flag bytes
     */
    public AvFlags(final byte[] raw) {
        super(AvPair.MsvAvFlags, raw);
    }

    /**
     * Constructs an AV flags pair from integer flags
     * @param flags the flag values as integer
     */

import java.nio.charset.StandardCharsets;

import org.junit.jupiter.api.Test;

class AvTargetNameTest {

    /**
     * Test constructor with raw bytes.
     * Verifies that the AvPair type is correctly set and raw bytes are stored.
     */
    @Test
    void testConstructorWithRawBytes() {
        byte[] rawBytes = "TEST_TARGET_NAME".getBytes(StandardCharsets.UTF_16LE);

Refer to the dashboard [json file here](https://raw.githubusercontent.com/minio/minio/master/docs/metrics/prometheus/grafana/minio-dashboard.json).

![Grafana](https://raw.githubusercontent.com/minio/minio/master/docs/metrics/prometheus/grafana/grafana-minio.png)

func (store *QueueStore[I]) GetRaw(key Key) (raw []byte, err error) {
	store.RLock()

	defer func(store *QueueStore[I]) {
		store.RUnlock()
		if err != nil && !os.IsNotExist(err) {
			// Upon error we remove the entry.
			store.Del(key)
		}
	}(store)

	raw, err = os.ReadFile(filepath.Join(store.directory, key.String()))
	if err != nil {
		return raw, err
	}

	if len(raw) == 0 {