public int hashCode() {
            return rawType().hashCode() + 17 * moduleName.hashCode();
        }

        /**
         * {@return whether the given object represents the same type of path as this object}.
         */
        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Modular m) {
                return rawType() == m.rawType() && moduleName.equals(m.moduleName);
            }

        }
        if (upperBounds != null) {
            return upperBounds.getRawType();
        }
        TypeMetaData rawType = new TypeMetaData(name);
        rawType.arrayDimensions = arrayDimensions;
        if (varargs) {
            rawType.arrayDimensions++;
        }
        return rawType;
    }

    public String getSignature() {
        final StringBuilder builder = new StringBuilder();

    @Test
    public void testConstructorWithRawBytes() {
        byte[] rawBytes = new byte[8];
        SMBUtil.writeInt8(1234567890L, rawBytes, 0); // Example timestamp
        AvTimestamp avTimestamp = new AvTimestamp(rawBytes);

        assertNotNull(avTimestamp);
        assertEquals(AvPair.MsvAvTimestamp, avTimestamp.getType());
        assertArrayEquals(rawBytes, avTimestamp.getRaw());
    }

    /**

        super("ECL0064", asArray(targetClass.getName(), MethodUtil.getSignature(targetClass.getSimpleName(), argTypes)), cause);
        this.targetClass = targetClass;
        this.argTypes = argTypes;
    }

    /**
     * Returns the target class.
     *
     * @return Target class
     */
    public Class<?> getTargetClass() {

     * 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);
        AvTargetName avTargetName = new AvTargetName(rawBytes);

        // Verify the AvPair type is MsvAvTargetName
        assertEquals(AvPair.MsvAvTargetName, avTargetName.getType(), "AvPair type should be MsvAvTargetName");

            throws NoSuchConstructorRuntimeException {
        assertArgumentNotNull("clazz", clazz);

        try {
            return clazz.getConstructor(argTypes);
        } catch (final NoSuchMethodException e) {
            throw new NoSuchConstructorRuntimeException(clazz, argTypes, e);
        }
    }

    /**

        @Override
        public <Q> Supplier<Q> getCompiledBinding(Dependency<Q> dep) {
            Key<Q> key = dep.key();
            Class<Q> rawType = key.getRawType();
            if (rawType == List.class) {
                return getListSupplier(key);
            } else if (rawType == Map.class) {
                return getMapSupplier(key);
            } else {
                return getBeanSupplier(dep, key);
            }

        buf.append(methodName).append("(");
        if (argTypes != null && argTypes.length > 0) {
            for (final Class<?> argType : argTypes) {
                buf.append(argType.getName()).append(", ");
            }
            buf.setLength(buf.length() - 2);
        }
        buf.append(")");
        return new String(buf);
    }

    /**
     * Returns the string representation of the method signature.
     *

     * Test constructor with raw bytes.
     */
    @Test
    void testAvFlagsByteArrayConstructor() {
        // Test with a positive integer
        byte[] rawBytes = new byte[] { 0x01, 0x02, 0x03, 0x04 }; // Represents 0x04030201 (little-endian)
        AvFlags avFlags = new AvFlags(rawBytes);
        assertNotNull(avFlags, "AvFlags object should not be null");

      }
      if (type instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) type;
        Class<?> rawType = (Class<?>) parameterizedType.getRawType();
        TypeVariable<?>[] typeVars = rawType.getTypeParameters();
        Type[] typeArgs = parameterizedType.getActualTypeArguments();
        for (int i = 0; i < typeArgs.length; i++) {