private final TypeWrapper[] actualTypeArguments;
    private final ClassTypeWrapper rawType;
    private final TypeWrapper ownerType;
    private final int hashCode;

    public ParameterizedTypeWrapper(TypeWrapper[] actualTypeArguments, ClassTypeWrapper rawType, @Nullable TypeWrapper ownerType) {
        this.actualTypeArguments = actualTypeArguments;
        this.rawType = rawType;

        _ * services.get(_) >> { Type type ->
            if (type instanceof ParameterizedType) {
                assert type.rawType == List.class
                assert type.actualTypeArguments.length == 1
                assert type.actualTypeArguments[0] == String
                return ["Hello", "Number"]
            }
            assert type == Number
            return 12
        }

        when:

        private final Type rawType;
        private final Type[] actualTypeArguments;

        ParameterizedTypeImpl(@Nullable Type ownerType, Type rawType, Type[] actualTypeArguments) {
            this.ownerType = ownerType;
            this.rawType = rawType;
            this.actualTypeArguments = actualTypeArguments;
        }

        @Override
        public Type getRawType() {

    when {
        isArray ->
            "Array<${kotlinTypeStringFor(componentType!!)}>"
        isParameterized ->
            "$parameterizedTypeDefinition<${actualTypeArguments.joinToString(transform = ::kotlinTypeStringFor)}>"
        isWildcard ->
            (upperBound ?: lowerBound)?.let(::kotlinTypeStringFor) ?: "Any"
        else ->

    /**
     * Create a stub context based on the type parameter of the extended StepSpec.
     */
    private C createContext() {
        def contextType = (getClass().getGenericSuperclass() as ParameterizedType).actualTypeArguments[0] as Class<C>
        return Stub(contextType, defaultResponse: GuavaImmutablesResponse.INSTANCE) as C
    }

    protected TestFile file(Object... path) {
        return temporaryFolder.file(path)
    }

    }

    def "componentType is null on non-array types"() {
        expect:
        typeOf(String).componentType == null
        new TypeOf<List<String>>() {}.componentType == null
        new TypeOf<List<?>>() {}.actualTypeArguments[0].with { wildcard && componentType == null }
    }

    def "getFullyQualifiedName returns FQN"() {
        given:
        def stringType = typeOf(String)

        expect:

        generatedType.getMethod("getValues").genericReturnType.actualTypeArguments == [String]

        generatedType.getMethod("getOptional").returnType == Optional
        generatedType.getMethod("getOptional").genericReturnType.actualTypeArguments == [Boolean]

        generatedType.getMethod("setOptional", Optional).genericParameterTypes*.actualTypeArguments == [[Boolean]]
    }

private
val TypeOf<*>.kmType: KmType
    get() = when {
        isParameterized -> genericTypeOf(
            classOf(parameterizedTypeDefinition.concreteClass),
            actualTypeArguments.map { it.kmType }
        )

        isWildcard -> (upperBound ?: lowerBound)?.kmType ?: KotlinType.any
        else -> classOf(concreteClass)
    }


internal