assertThat(desc.getRawClass(), is(sameClass(Set.class)));
        ParameterizedClassDesc[] args = desc.getArguments();
        assertThat(args.length, is(1));
        assertThat(args[0].getRawClass(), is(sameClass(Integer.class)));

        desc = ParameterizedClassDescFactory.createParameterizedClassDesc(method, 1, map);
        assertThat(desc.getRawClass(), is(sameClass(Map.class)));

    /**
     * Returns the raw class.
     *
     * @param <T>
     *            the type of the raw class
     * @return the raw class
     * @see ParameterizedType#getRawType()
     */
    <T> Class<T> getRawClass();

    /**
     * Returns an array of {@link ParameterizedClassDesc} representing the type arguments.
     * <p>
     * If the class represented by this instance is not a parameterized class, returns {@literal null}.

     */
    public static Class<?> getRawClass(final Type type) {
        return switch (type) {
        case Class<?> clazz -> clazz;
        case ParameterizedType paramType -> getRawClass(paramType.getRawType());
        case WildcardType wildcard -> getRawClass(wildcard.getUpperBounds()[0]);
        case GenericArrayType arrayType -> {
            Class<?> rawClass = getRawClass(arrayType.getGenericComponentType());

            return null;
        }
        final ParameterizedClassDesc pcd = parameterizedClassDesc.getArguments()[0];
        if (pcd == null) {
            return null;
        }
        return pcd.getRawClass();
    }

    @Override
    public Class<?> getKeyClassOfMap() {
        if (!Map.class.isAssignableFrom(fieldType) || !isParameterized()) {
            return null;
        }

            return null;
        }
        final ParameterizedClassDesc pcd = parameterizedClassDescs[index].getArguments()[0];
        if (pcd == null) {
            return null;
        }
        return pcd.getRawClass();
    }

    @Override
    public Class<?> getKeyClassOfMap(final int index) {
        assertArgumentArrayIndex("index", index, parameterTypes.length);

            return null;
        }
        final ParameterizedClassDesc pcd = parameterizedClassDescs[index].getArguments()[0];
        if (pcd == null) {
            return null;
        }
        return pcd.getRawClass();
    }

    @Override
    public Class<?> getKeyClassOfMap(final int index) {
        assertArgumentArrayIndex("index", index, parameterTypes.length);

     */
    public static Class<?> getElementTypeOfCollection(final Field field) {
        assertArgumentNotNull("field", field);

        final Type type = field.getGenericType();
        return GenericsUtil.getRawClass(GenericsUtil.getElementTypeOfCollection(type));
    }

    /**
     * Returns the key type of a parameterized map field.
     *
     * @param field a field of a parameterized map type (must not be {@literal null})

            return null;
        }
        final ParameterizedClassDesc pcd = parameterizedClassDesc.getArguments()[0];
        if (pcd == null) {
            return null;
        }
        return pcd.getRawClass();
    }

    @Override
    public Class<?> getKeyClassOfMap() {
        if (!Map.class.isAssignableFrom(propertyType) || !isParameterized()) {
            return null;
        }

        final Method m1 = ArrayType.class.getMethod("arrayOfStringClass");
        final Type t1 = m1.getGenericReturnType();
        final Type t2 = GenericsUtil.getElementTypeOfArray(t1);
        assertThat(GenericsUtil.getRawClass(t2), is(sameClass(Class.class)));
        assertThat(GenericsUtil.getGenericParameter(t2, 0), is(sameClass(String.class)));
    }

    /**
     * @throws Exception
     */