use of spoon.reflect.code.CtFieldRead in project spoon by INRIA.
the class TypeTest method testTypeAccessForDotClass.
@Test
public void testTypeAccessForDotClass() throws Exception {
// contract: When we use .class on a type, this must be a CtTypeAccess.
final String target = "./target/type";
final Launcher launcher = new Launcher();
launcher.addInputResource("./src/test/java/spoon/test/type/testclasses");
launcher.setSourceOutputDirectory(target);
launcher.getEnvironment().setNoClasspath(true);
launcher.run();
final CtClass<Pozole> aPozole = launcher.getFactory().Class().get(Pozole.class);
final CtMethod<?> make = aPozole.getMethodsByName("make").get(0);
final List<CtFieldRead<?>> fieldClasses = make.getElements(new TypeFilter<CtFieldRead<?>>(CtFieldRead.class) {
@Override
public boolean matches(CtFieldRead<?> element) {
return "class".equals(element.getVariable().getSimpleName()) && super.matches(element);
}
});
assertEquals(4, fieldClasses.size());
for (CtFieldRead<?> fieldClass : fieldClasses) {
assertTrue(fieldClass.getTarget() instanceof CtTypeAccess);
}
canBeBuilt(target, 8, true);
}
use of spoon.reflect.code.CtFieldRead in project spoon by INRIA.
the class AccessTest method testVariableAccessInNoClasspath.
@Test
public void testVariableAccessInNoClasspath() throws Exception {
final Launcher launcher = new Launcher();
launcher.getEnvironment().setNoClasspath(true);
launcher.addInputResource("./src/test/resources/variable");
launcher.setSourceOutputDirectory("./target/variable/");
launcher.run();
final CtClass<Object> aClass = launcher.getFactory().Class().get("org.argouml.uml.ui.behavior.use_cases.PropPanelUseCase");
final List<CtFieldRead> elements = aClass.getElements(new TypeFilter<>(CtFieldRead.class));
for (CtFieldRead element : elements) {
assertNotNull(element.getVariable());
}
assertEquals("java.lang.Class mclass = ((java.lang.Class) (org.argouml.model.ModelFacade.USE_CASE))", elements.get(0).getParent().toString());
assertEquals("new org.argouml.uml.ui.PropPanelButton(this, buttonPanel, _navUpIcon, org.argouml.i18n.Translator.localize(\"UMLMenu\", \"button.go-up\"), \"navigateNamespace\", null)", elements.get(2).getParent().toString());
}
use of spoon.reflect.code.CtFieldRead in project spoon by INRIA.
the class FieldTest method testGetDefaultExpression.
@Test
public void testGetDefaultExpression() throws Exception {
Launcher spoon = new Launcher();
spoon.addInputResource("./src/test/java/spoon/test/field/testclasses/A.java");
spoon.addInputResource("./src/test/java/spoon/test/field/testclasses/BaseClass.java");
spoon.buildModel();
final CtClass<A> aClass = spoon.getFactory().Class().get(A.class);
CtClass<A.ClassB> bClass = aClass.getFactory().Class().get(A.ClassB.class);
List<CtMethod<?>> methods = bClass.getMethodsByName("getKey");
assertEquals(1, methods.size());
CtReturn<?> returnExpression = methods.get(0).getBody().getStatement(0);
CtFieldRead fieldRead = (CtFieldRead) returnExpression.getReturnedExpression();
assertEquals("spoon.test.field.testclasses.BaseClass.PREFIX", fieldRead.toString());
CtField<?> field = fieldRead.getVariable().getDeclaration();
CtClass<BaseClass> baseClass = aClass.getFactory().Class().get(BaseClass.class);
CtField<?> expectedField = baseClass.getField("PREFIX");
assertEquals(expectedField, field);
VisitorPartialEvaluator visitorPartial = new VisitorPartialEvaluator();
Object retour = visitorPartial.evaluate(methods.get(0));
assertTrue(retour != null);
}
use of spoon.reflect.code.CtFieldRead in project spoon by INRIA.
the class FieldAccessTest method testFieldAccessInAnonymousClass.
@Test
public void testFieldAccessInAnonymousClass() throws Exception {
final Factory factory = build(Panini.class);
final CtType<Panini> panini = factory.Type().get(Panini.class);
final CtFieldRead fieldInAnonymous = panini.getElements(new TypeFilter<>(CtFieldRead.class)).get(0);
assertEquals("ingredient", fieldInAnonymous.getTarget().toString());
assertEquals("next", fieldInAnonymous.getVariable().getSimpleName());
assertEquals("ingredient.next", fieldInAnonymous.toString());
}
use of spoon.reflect.code.CtFieldRead in project spoon by INRIA.
the class MetamodelTest method testRoleOnField.
@Test
public void testRoleOnField() {
// contract: all non-final fields must be annotated with {@link spoon.reflect.annotations.MetamodelPropertyField}
SpoonAPI implementations = new Launcher();
implementations.addInputResource("src/main/java/spoon/support/reflect");
implementations.buildModel();
Factory factory = implementations.getFactory();
CtTypeReference metamodelPropertyField = factory.Type().get(MetamodelPropertyField.class).getReference();
final List<String> result = new ArrayList();
List<CtField> fieldWithoutAnnotation = (List<CtField>) implementations.getModel().getElements(new TypeFilter<CtField>(CtField.class) {
@Override
public boolean matches(CtField candidate) {
if (candidate.hasModifier(ModifierKind.FINAL) || candidate.hasModifier(ModifierKind.STATIC) || candidate.hasModifier(ModifierKind.TRANSIENT)) {
return false;
}
if (// not a role
"parent".equals(candidate.getSimpleName()) || "metadata".equals(candidate.getSimpleName()) || // cache field
"valueOfMethod".equals(candidate.getSimpleName())) {
return false;
}
CtClass parent = candidate.getParent(CtClass.class);
return parent != null && (parent.isSubtypeOf(candidate.getFactory().createCtTypeReference(CtReference.class)) || parent.isSubtypeOf(candidate.getFactory().createCtTypeReference(CtElement.class)));
}
}).stream().map(x -> {
result.add(x.toString());
return x;
}).filter(f -> f.getAnnotation(metamodelPropertyField) == null).collect(Collectors.toList());
assertTrue(result.contains("@spoon.reflect.annotations.MetamodelPropertyField(role = spoon.reflect.path.CtRole.IS_SHADOW)\nboolean isShadow;"));
assertTrue(result.contains("@spoon.reflect.annotations.MetamodelPropertyField(role = spoon.reflect.path.CtRole.TYPE)\nspoon.reflect.reference.CtTypeReference<T> type;"));
assertTrue(result.size() > 100);
Assert.assertEquals(Collections.emptyList(), fieldWithoutAnnotation);
final CtTypeReference propertySetter = factory.Type().get(PropertySetter.class).getReference();
final CtTypeReference propertyGetter = factory.Type().get(PropertyGetter.class).getReference();
List<CtField> fields = factory.getModel().getElements(new AnnotationFilter<CtField>(MetamodelPropertyField.class));
for (CtField field : fields) {
CtClass parent = field.getParent(CtClass.class);
CtExpression roleExpression = field.getAnnotation(metamodelPropertyField).getValue("role");
List<String> roles = new ArrayList<>();
if (roleExpression instanceof CtFieldRead) {
roles.add(((CtFieldRead) roleExpression).getVariable().getSimpleName());
} else if (roleExpression instanceof CtNewArray) {
List<CtFieldRead> elements = ((CtNewArray) roleExpression).getElements();
for (int i = 0; i < elements.size(); i++) {
CtFieldRead ctFieldRead = elements.get(i);
roles.add(ctFieldRead.getVariable().getSimpleName());
}
}
CtQuery superQuery = parent.map(new SuperInheritanceHierarchyFunction());
List<CtMethod> methods = superQuery.map((CtType type) -> type.getMethodsAnnotatedWith(propertyGetter, propertySetter)).list();
boolean setterFound = false;
boolean getterFound = false;
for (CtMethod method : methods) {
CtAnnotation getterAnnotation = method.getAnnotation(propertyGetter);
CtAnnotation setterAnnotation = method.getAnnotation(propertySetter);
if (getterAnnotation != null) {
getterFound |= roles.contains(((CtFieldRead) getterAnnotation.getValue("role")).getVariable().getSimpleName());
}
if (setterAnnotation != null) {
setterFound |= roles.contains(((CtFieldRead) setterAnnotation.getValue("role")).getVariable().getSimpleName());
}
}
assertTrue(roles + " must have a getter in " + parent.getQualifiedName(), getterFound);
assertTrue(roles + " must have a setter in " + parent.getQualifiedName(), setterFound);
}
}
Aggregations