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(

				"image/x-portable-pixmap",
				"image/x-raw-adobe",
				"image/x-raw-hasselblad",
				"image/x-raw-fuji",
				"image/x-raw-canon",
				"image/x-raw-kodak",
				"image/x-raw-minolta",
				"image/x-raw-nikon",
				"image/x-raw-olympus",
				"image/x-raw-pentax",
				"image/x-raw-sony",
				"image/x-raw-sigma",
				"image/x-raw-epson",
				"image/x-raw-mamiya",
				"image/x-raw-leaf",

    <_comment>Leaf raw image</_comment>
    <glob pattern="*.mos"/>
  </mime-type>

  <mime-type type="image/x-raw-panasonic">
    <_comment>Panasonic raw image</_comment>
    <glob pattern="*.raw"/>
    <glob pattern="*.rw2"/>
  </mime-type>

  <mime-type type="image/x-raw-phaseone">
    <_comment>Phase One raw image</_comment>
    <glob pattern="*.iiq"/>
  </mime-type>

obtained from concatenating a sequence of characters. There are two forms:
raw string literals and interpreted string literals.
</p>

<p>
Raw string literals are character sequences between back quotes, as in
<code>`foo`</code>.  Within the quotes, any character may appear except
back quote. The value of a raw string literal is the
string composed of the uninterpreted (implicitly UTF-8-encoded) characters

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

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

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 {