public ResolvedType classToResolvedType(Class<?> clazz) { if (clazz.isPrimitive()) { return ResolvedPrimitiveType.byName(clazz.getName()); } return new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver); } }
public ResolvedType classToResolvedType(Class<?> clazz) { if (clazz.isPrimitive()) { return ResolvedPrimitiveType.byName(clazz.getName()); } return new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver); } }
public ResolvedType classToResolvedType(Class<?> clazz) { if (clazz.isPrimitive()) { return ResolvedPrimitiveType.byName(clazz.getName()); } return new ReferenceTypeImpl(new ReflectionClassDeclaration(clazz, typeSolver), typeSolver); } }
@Override public ResolvedReferenceTypeDeclaration declaringType() { if (method.getDeclaringClass().isInterface()) { return new ReflectionInterfaceDeclaration(method.getDeclaringClass(), typeSolver); } if (method.getDeclaringClass().isEnum()) { return new ReflectionEnumDeclaration(method.getDeclaringClass(), typeSolver); } else { return new ReflectionClassDeclaration(method.getDeclaringClass(), typeSolver); } }
@Override public ResolvedReferenceTypeDeclaration declaringType() { if (method.getDeclaringClass().isInterface()) { return new ReflectionInterfaceDeclaration(method.getDeclaringClass(), typeSolver); } if (method.getDeclaringClass().isEnum()) { return new ReflectionEnumDeclaration(method.getDeclaringClass(), typeSolver); } else { return new ReflectionClassDeclaration(method.getDeclaringClass(), typeSolver); } }
@Override public ResolvedType visit(ClassExpr node, Boolean solveLambdas) { // This implementation does not regard the actual type argument of the ClassExpr. com.github.javaparser.ast.type.Type astType = node.getType(); ResolvedType jssType = facade.convertToUsage(astType, node.getType()); return new ReferenceTypeImpl(new ReflectionClassDeclaration(Class.class, typeSolver), ImmutableList.of(jssType), typeSolver); }
@Test public void testGetInterfaces() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver); // Serializable, Cloneable, List<E>, RandomAccess assertEquals(ImmutableSet.of(Serializable.class.getCanonicalName(), Cloneable.class.getCanonicalName(), List.class.getCanonicalName(), RandomAccess.class.getCanonicalName()), arraylist.getInterfaces().stream().map(i -> i.getQualifiedName()).collect(Collectors.toSet())); }
@Before public void setup() { typeSolver = new ReflectionTypeSolver(); string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver); object = new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver); listOfString = listOf(string); tpE = EasyMock.createMock(ResolvedTypeParameterDeclaration.class); EasyMock.expect(tpE.getName()).andReturn("T").anyTimes(); EasyMock.replay(tpE); listOfE = listOf(new ResolvedTypeVariable(tpE)); }
@Test public void testGetAllFields() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver); assertEquals(ImmutableSet.of("modCount", "serialVersionUID", "MAX_ARRAY_SIZE", "size", "elementData", "EMPTY_ELEMENTDATA", "DEFAULTCAPACITY_EMPTY_ELEMENTDATA", "DEFAULT_CAPACITY"), arraylist.getAllFields().stream().map(ResolvedDeclaration::getName).collect(Collectors.toSet())); }
@Before public void setup() { tpA = new ResolvedTypeVariable(ResolvedTypeParameterDeclaration.onType("A", "foo.Bar", Collections.emptyList())); typeSolver = new ReflectionTypeSolver(); tpString = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver); }
@Test public void testGetFunctionalMethodNegativeCaseOnClass() { TypeSolver typeSolver = new ReflectionTypeSolver(); ResolvedType string = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver); assertEquals(false, FunctionalInterfaceLogic.getFunctionalMethod(string).isPresent()); }
@Test public void testGetQualifiedName() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver); assertEquals("java.util.ArrayList", arraylist.getQualifiedName()); ResolvedClassDeclaration string = new ReflectionClassDeclaration(String.class, typeResolver); assertEquals("java.lang.String", string.getQualifiedName()); }
@Test public void testGetClassName() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver); assertEquals("ArrayList", arraylist.getClassName()); ResolvedClassDeclaration string = new ReflectionClassDeclaration(String.class, typeResolver); assertEquals("String", string.getClassName()); }
@Test public void testGetPackageName() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration arraylist = new ReflectionClassDeclaration(ArrayList.class, typeResolver); assertEquals("java.util", arraylist.getPackageName()); ResolvedClassDeclaration string = new ReflectionClassDeclaration(String.class, typeResolver); assertEquals("java.lang", string.getPackageName()); }
@Before public void setup() { typeSolver = new ReflectionTypeSolver(); OBJECT = new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeSolver), typeSolver); STRING = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver); arrayOfBooleans = new ResolvedArrayType(ResolvedPrimitiveType.BOOLEAN); arrayOfListOfA = new ResolvedArrayType(new ReferenceTypeImpl( new ReflectionInterfaceDeclaration(List.class, typeSolver), ImmutableList.of(new ResolvedTypeVariable(ResolvedTypeParameterDeclaration.onType("A", "foo.Bar", Collections.emptyList()))), typeSolver)); }
@Test public void testAllAncestors() { TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedInterfaceDeclaration list = new ReflectionInterfaceDeclaration(List.class, typeResolver); Map<String, ResolvedReferenceType> ancestors = new HashMap<>(); list.getAllAncestors().forEach(a -> ancestors.put(a.getQualifiedName(), a)); assertEquals(3, ancestors.size()); ResolvedTypeVariable typeVariable = new ResolvedTypeVariable(list.getTypeParameters().get(0)); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Collection.class, typeResolver), ImmutableList.of(typeVariable), typeResolver), ancestors.get("java.util.Collection")); assertEquals(new ReferenceTypeImpl(new ReflectionClassDeclaration(Object.class, typeResolver), typeResolver), ancestors.get("java.lang.Object")); assertEquals(new ReferenceTypeImpl(new ReflectionInterfaceDeclaration(Iterable.class, typeResolver), ImmutableList.of(typeVariable), typeResolver), ancestors.get("java.lang.Iterable")); }
@Test public void solveMethodAsUsageWithMoreSpecializedParameter() throws ParseException { CompilationUnit cu = parseSample("ClassWithMethods"); ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A"); Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver); ResolvedType stringType = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver); Optional<MethodUsage> ref = context.solveMethodAsUsage("foo4", ImmutableList.of(stringType), new ReflectionTypeSolver()); assertEquals(true, ref.isPresent()); assertEquals("A", ref.get().declaringType().getName()); assertEquals(1, ref.get().getNoParams()); }
@Test public void testGetSuperclassSimpleImplicit() { class Foo<E> { E field; } TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration foo = new ReflectionClassDeclaration(Foo.class, typeResolver); assertEquals(Object.class.getCanonicalName(), foo.getSuperClass().getQualifiedName()); assertEquals(Collections.emptyList(), foo.getSuperClass().typeParametersValues()); }
@Test public void testGetSuperclassSimple() { class Bar { } class Foo<E> extends Bar { E field; } TypeSolver typeResolver = new ReflectionTypeSolver(); ResolvedClassDeclaration foo = new ReflectionClassDeclaration(Foo.class, typeResolver); assertEquals("Bar", foo.getSuperClass().getTypeDeclaration().getName()); assertEquals(Collections.emptyList(), foo.getSuperClass().typeParametersValues()); }
@Test public void solveMethodWithMoreSpecializedParameter() throws ParseException { CompilationUnit cu = parseSample("ClassWithMethods"); ClassOrInterfaceDeclaration classOrInterfaceDeclaration = Navigator.demandClass(cu, "A"); Context context = new ClassOrInterfaceDeclarationContext(classOrInterfaceDeclaration, typeSolver); ResolvedType stringType = new ReferenceTypeImpl(new ReflectionClassDeclaration(String.class, typeSolver), typeSolver); SymbolReference<ResolvedMethodDeclaration> ref = context.solveMethod("foo4", ImmutableList.of(stringType), false, new ReflectionTypeSolver()); assertEquals(true, ref.isSolved()); assertEquals("A", ref.getCorrespondingDeclaration().declaringType().getName()); assertEquals(1, ref.getCorrespondingDeclaration().getNumberOfParams()); }