Example usage for org.springframework.core ResolvableType hasGenerics

List of usage examples for org.springframework.core ResolvableType hasGenerics

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.core.*
  5. ResolvableType
  6. hasGenerics

Introduction

In this page you can find the example usage for org.springframework.core ResolvableType hasGenerics.

Prototype

public boolean hasGenerics()

Source Link

Document

Return true if this type contains generic parameters.

Usage

From source file:org.brutusin.rpc.RpcComponent.java

/**
 *
 * @param rt//from w w  w .j  a  v  a2 s.  c  o  m
 * @return
 */
protected static Type getType(final ResolvableType rt) {
    if (!rt.hasGenerics()) {
        return rt.resolve();
    } else {
        return new ParameterizedType() {
            public Type[] getActualTypeArguments() {
                Type[] ret = new Type[rt.getGenerics().length];
                for (int i = 0; i < ret.length; i++) {
                    ret[i] = getType(rt.getGenerics()[i]);
                }
                return ret;
            }

            public Type getRawType() {
                return rt.resolve();
            }

            public Type getOwnerType() {
                return null;
            }
        };
    }
}

From source file:com.fitbur.jestify.junit.spring.injector.IndexMockInjector.java

@Override
public void inject() {
    Map<DescriptorKey, ParameterDescriptor> parameterDescriptors = context.getParamaterDescriptors();
    Field field = fieldDescriptor.getField();

    Mock mock = fieldDescriptor.getMock().get();
    Integer index = mock.index();
    Optional<ParameterDescriptor> optional = parameterDescriptors.values().parallelStream()
            .filter(p -> index.equals(p.getIndex())).findFirst();

    ParameterDescriptor parameterDescriptor = optional.get();
    Parameter parameter = parameterDescriptor.getParameter();

    Type fieldType = field.getGenericType();
    Type parameterType = parameter.getParameterizedType();

    checkArgument(fieldType.equals(parameterType),
            "Can not mock field '%s'. Test class field type '%s' and class under test "
                    + "constructor parameter type '%s' at '%d' index do not match.",
            field.getName(), field.getGenericType(), parameterType, index);

    ResolvableType resolver = ResolvableType.forType(parameterType);

    Class rawType;//from   ww w . ja  v  a2  s . c o m

    if (resolver.hasGenerics()) {
        if (resolver.isAssignableFrom(Provider.class) || resolver.isAssignableFrom(Optional.class)) {
            rawType = resolver.getRawClass();
        } else {
            rawType = resolver.resolve();
        }
    } else {
        rawType = (Class) parameterType;
    }

    checkArgument(arguments[index] == null,
            "Can not mock field '%s'. Multipe test class fields have the same index of '%d'", field.getName(),
            index);

    Object instance = testReifier.reifyField(fieldDescriptor, parameterDescriptor);
    arguments[index] = instance;
}

From source file:com.fitbur.jestify.junit.spring.injector.NameMockInjector.java

@Override
public void inject() {
    Map<DescriptorKey, ParameterDescriptor> parameterDescriptors = context.getParamaterDescriptors();
    Field field = fieldDescriptor.getField();
    Type fieldType = field.getGenericType();

    Mock mock = fieldDescriptor.getMock().get();
    String mockName = mock.name();
    DescriptorKey descriptorKey = new DescriptorKey(fieldType, mockName);

    ParameterDescriptor parameterDescriptor = parameterDescriptors.get(descriptorKey);

    checkArgument(parameterDescriptor != null,
            "Can not mock field '%s'. Could not find class under test constructor "
                    + "argument with the name '%s'.",
            field.getName(), mockName);//from  www. j a  v  a2  s.c  o  m

    Parameter parameter = parameterDescriptor.getParameter();
    Integer index = parameterDescriptor.getIndex();
    Type parameterType = parameter.getParameterizedType();

    checkArgument(fieldType.equals(parameterType),
            "Can not mock field '%s'. Test class field type '%s' and class under test "
                    + "constructor parameter type '%s' with name '%s' do not match.",
            field.getName(), field.getGenericType(), parameterType, mockName);

    ResolvableType resolver = ResolvableType.forType(parameterType);

    Class rawType;

    if (resolver.hasGenerics()) {
        if (resolver.isAssignableFrom(Provider.class) || resolver.isAssignableFrom(Optional.class)) {
            rawType = resolver.getRawClass();
        } else {
            rawType = resolver.resolve();
        }
    } else {
        rawType = (Class) parameterType;
    }

    checkArgument(arguments[index] == null,
            "Can not mock field '%s'. Multipe test class fields have the same index of '%d'", field.getName(),
            index);

    Object instance = testReifier.reifyField(fieldDescriptor, parameterDescriptor);

    arguments[index] = instance;
}

From source file:com.fitbur.jestify.junit.spring.injector.TypeMockInjector.java

@Override
public void inject() {
    Map<DescriptorKey, ParameterDescriptor> parameterDescriptors = context.getParamaterDescriptors();
    Field field = fieldDescriptor.getField();

    Mock mock = fieldDescriptor.getMock().get();
    Type fieldType = field.getGenericType();
    String fieldName = field.getName();
    DescriptorKey descriptorKey = new DescriptorKey(fieldType, fieldName);

    //if there is a parameter descriptor that matches the field then lets use that
    if (parameterDescriptors.containsKey(descriptorKey)) {
        ParameterDescriptor descriptor = parameterDescriptors.get(descriptorKey);
        Parameter parameter = descriptor.getParameter();
        Integer index = descriptor.getIndex();
        ResolvableType resolver = ResolvableType.forType(fieldType);

        Class rawType;//from  w w w  .  j a v  a2  s .c o m

        if (resolver.hasGenerics()) {
            if (resolver.isAssignableFrom(Provider.class) || resolver.isAssignableFrom(Optional.class)) {
                rawType = resolver.getRawClass();
            } else {
                rawType = resolver.resolve();
            }
        } else {
            rawType = (Class) fieldType;
        }
        Object instance = testReifier.reifyField(fieldDescriptor, descriptor);
        arguments[index] = instance;
    } else {
        //otherwise find the right parameter based on the type of the field
        Collection<ParameterDescriptor> descriptors = parameterDescriptors.values();
        for (ParameterDescriptor descriptor : descriptors) {
            Parameter parameter = descriptor.getParameter();
            Type parameterType = parameter.getParameterizedType();
            Integer index = descriptor.getIndex();

            ResolvableType resolver = ResolvableType.forType(parameterType);

            Class rawType;

            if (resolver.hasGenerics()) {
                if (resolver.isAssignableFrom(Provider.class) || resolver.isAssignableFrom(Optional.class)) {
                    rawType = resolver.getRawClass();
                } else {
                    rawType = resolver.resolve();
                }
            } else {
                rawType = resolver.resolve();
            }

            if (arguments[index] != null) {
                continue;
            }

            if (parameterType.equals(fieldType)) {
                Object instance = testReifier.reifyField(fieldDescriptor, descriptor);
                arguments[index] = instance;
                break;
            }

        }
    }

}

From source file:com.fitbur.jestify.junit.spring.IntegrationTestReifier.java

@Override
public Object reifyCut(CutDescriptor cutDescriptor, Object[] arguments) {
    return AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        try {//from   w ww  . ja  v  a2  s.  c o m
            Cut cut = cutDescriptor.getCut();
            Field field = cutDescriptor.getField();
            Type fieldType = field.getGenericType();
            String fieldName = field.getName();

            field.setAccessible(true);

            Constructor<?> constructor = cutDescriptor.getConstructor();
            constructor.setAccessible(true);

            ResolvableType resolver = ResolvableType.forType(fieldType);

            Class rawType;

            if (resolver.hasGenerics()) {
                if (resolver.isAssignableFrom(Provider.class) || resolver.isAssignableFrom(Optional.class)) {
                    rawType = resolver.getRawClass();
                } else {
                    rawType = resolver.resolve();
                }
            } else {
                rawType = resolver.resolve();
            }

            Module module = testInstance.getClass().getDeclaredAnnotation(Module.class);

            GenericBeanDefinition bean = new GenericBeanDefinition();
            bean.setBeanClass(rawType);
            bean.setAutowireCandidate(false);
            bean.setScope(SCOPE_PROTOTYPE);
            bean.setPrimary(true);
            bean.setLazyInit(true);
            bean.setRole(RootBeanDefinition.ROLE_APPLICATION);
            bean.setAutowireMode(RootBeanDefinition.AUTOWIRE_NO);
            appContext.registerBeanDefinition(fieldName, bean);
            if (module != null) {
                appContext.register(module.value());
            }
            appContext.refresh();

            Object instance = appContext.getBean(fieldName, arguments);

            if (cut.value()) {
                instance = spy(instance);
            }

            field.set(testInstance, instance);

            return instance;
        } catch (SecurityException | IllegalAccessException | IllegalArgumentException e) {
            throw new RuntimeException(e);
        }
    });
}

From source file:com.fitbur.jestify.junit.spring.IntegrationTestReifier.java

@Override
public Object reifyField(FieldDescriptor fieldDescriptor, ParameterDescriptor parameterDescriptor) {
    return AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        try {//w w  w . j a  v  a  2  s  . com
            Object instance;
            Field field = fieldDescriptor.getField();
            Type fieldType = field.getGenericType();
            field.setAccessible(true);

            Optional<Mock> optMock = fieldDescriptor.getMock();
            if (optMock.isPresent()) {
                Mock mock = optMock.get();
                Object value = field.get(testInstance);
                //if the field value is set then create a mock otherwise create a mock
                //that delegates to the value
                if (value == null) {
                    MockSettings settings = withSettings().defaultAnswer(mock.answer());

                    if (mock.extraInterfaces().length > 0) {
                        settings.extraInterfaces(mock.extraInterfaces());

                    }

                    instance = mock(field.getType(), settings);
                } else {
                    instance = mock(field.getType(), delegatesTo(value));
                }

            } else {
                ResolvableType resolver = ResolvableType.forType(fieldType);

                Class rawType;

                if (resolver.hasGenerics()) {
                    if (resolver.isAssignableFrom(Provider.class)
                            || resolver.isAssignableFrom(Optional.class)) {
                        rawType = resolver.getRawClass();
                    } else {
                        rawType = resolver.resolve();
                    }
                } else {
                    rawType = (Class) fieldType;
                }

                instance = appContext.getBean(rawType);
            }

            field.set(testInstance, instance);
            fieldDescriptor.setInstance(instance);
            parameterDescriptor.setInstance(instance);

            return instance;
        } catch (IllegalAccessException | IllegalArgumentException e) {
            throw new RuntimeException(e);
        }
    });

}