Examples with CtEnum spoon.reflect.declaration.CtEnum used on opensource projects

Example 1 with CtEnum

use of spoon.reflect.declaration.CtEnum in project spoon by INRIA.

the class EnumsTest method testAnnotationsOnEnum.

@Test
public void testAnnotationsOnEnum() throws Exception {
    final Launcher launcher = new Launcher();
    launcher.run(new String[] { "-i", "./src/test/java/spoon/test/enums/testclasses", "-o", "./target/spooned" });
    final CtEnum<?> foo = (CtEnum) launcher.getFactory().Type().get(Foo.class);
    assertEquals(1, foo.getFields().size());
    assertEquals(1, foo.getFields().get(0).getAnnotations().size());
    assertEquals(Deprecated.class, AnnotationTest.getActualClassFromAnnotation(foo.getFields().get(0).getAnnotations().get(0)));
    assertEquals("public enum Foo {" + DefaultJavaPrettyPrinter.LINE_SEPARATOR + "    @java.lang.Deprecated" + DefaultJavaPrettyPrinter.LINE_SEPARATOR + "    Bar;}", foo.toString());
}

Example 2 with CtEnum

use of spoon.reflect.declaration.CtEnum in project spoon by INRIA.

the class EnumsTypeTest method testEnumsType.

@Test
public void testEnumsType() throws Exception {
    // contract: shadow enum should still be considered as an enum
    Launcher launcher = new Launcher();
    launcher.addInputResource("./src/test/resources/reference-test/EnumsRef.java");
    Factory factory = launcher.getFactory();
    List<SpoonResource> classpath = SpoonResourceHelper.resources("./src/test/resources/reference-test/EnumJar.jar");
    String[] dependencyClasspath = new String[] { classpath.get(0).getPath() };
    factory.getEnvironment().setSourceClasspath(dependencyClasspath);
    assertEquals(1, classpath.size());
    launcher.buildModel();
    List<CtAssignment> assignments = Query.getElements(factory, new TypeFilter<>(CtAssignment.class));
    CtTypeReference typeRefFromSource = assignments.get(0).getType();
    CtType typeFromSource = typeRefFromSource.getTypeDeclaration();
    assertTrue(typeRefFromSource.isEnum());
    assertTrue(typeFromSource.isEnum());
    assertTrue(typeFromSource instanceof CtEnum);
    CtTypeReference typeRefFromJar = assignments.get(1).getType();
    CtType typeFromJar = typeRefFromJar.getTypeDeclaration();
    // fail
    assertTrue(typeRefFromJar.isEnum());
    // fail
    assertTrue(typeFromJar.isEnum());
    // fail
    assertTrue(typeFromJar instanceof CtEnum);
}

Example 3 with CtEnum

use of spoon.reflect.declaration.CtEnum in project spoon by INRIA.

the class TypeReferenceTest method testCorrectEnumParent.

@Test
public void testCorrectEnumParent() {
    final Launcher launcher = new Launcher();
    launcher.getEnvironment().setNoClasspath(true);
    launcher.buildModel();
    CtEnum e = launcher.getFactory().Enum().create("spoon.test.reference.EnumE");
    CtTypeReference correctParent = launcher.getFactory().Type().createReference(java.lang.Enum.class);
    assertEquals(correctParent, e.getReference().getSuperclass());
}

Example 4 with CtEnum

use of spoon.reflect.declaration.CtEnum in project spoon by INRIA.

the class JavaReflectionTreeBuilder method visitEnum.

@Override
public <T> void visitEnum(Class<T> clazz) {
    final CtEnum ctEnum = factory.Core().createEnum();
    ctEnum.setSimpleName(clazz.getSimpleName());
    setModifier(ctEnum, clazz.getModifiers());
    enter(new TypeRuntimeBuilderContext(ctEnum) {

        @Override
        public void addConstructor(CtConstructor<?> ctConstructor) {
            ctEnum.addConstructor(ctConstructor);
        }

        @Override
        public void addEnumValue(CtEnumValue<?> ctEnumValue) {
            ctEnum.addEnumValue(ctEnumValue);
        }
    });
    super.visitEnum(clazz);
    exit();
    contexts.peek().addType(ctEnum);
}

Example 5 with CtEnum

use of spoon.reflect.declaration.CtEnum in project spoon by INRIA.

the class TemplateTest method createTypeFromTemplate.

@Test
public void createTypeFromTemplate() throws Exception {
    // contract: the Substitution API provides a method createTypeFromTemplate
    final Launcher launcher = new Launcher();
    launcher.setArgs(new String[] { "--output-type", "nooutput" });
    launcher.addTemplateResource(new FileSystemFolder("./src/test/java/spoon/test/template/testclasses/types"));
    launcher.buildModel();
    Factory factory = launcher.getFactory();
    Map<String, Object> parameters = new HashMap<>();
    // replace someMethod with genMethod
    parameters.put("someMethod", "genMethod");
    // contract: we can generate interface
    final CtType<?> aIfaceModel = launcher.getFactory().Interface().get(AnIfaceModel.class);
    CtType<?> genIface = Substitution.createTypeFromTemplate("generated.GenIface", aIfaceModel, parameters);
    assertNotNull(genIface);
    assertSame(genIface, factory.Type().get("generated.GenIface"));
    CtMethod<?> generatedIfaceMethod = genIface.getMethod("genMethod");
    assertNotNull(generatedIfaceMethod);
    assertNull(genIface.getMethod("someMethod"));
    // add new substitution request - replace AnIfaceModel by GenIface
    parameters.put("AnIfaceModel", genIface.getReference());
    // contract: we can generate class
    final CtType<?> aClassModel = launcher.getFactory().Class().get(AClassModel.class);
    CtType<?> genClass = Substitution.createTypeFromTemplate("generated.GenClass", aClassModel, parameters);
    assertNotNull(genClass);
    assertSame(genClass, factory.Type().get("generated.GenClass"));
    CtMethod<?> generatedClassMethod = genClass.getMethod("genMethod");
    assertNotNull(generatedClassMethod);
    assertNull(genClass.getMethod("someMethod"));
    assertTrue(generatedIfaceMethod != generatedClassMethod);
    assertTrue(generatedClassMethod.isOverriding(generatedIfaceMethod));
    // contract: we can generate enum
    parameters.put("case1", "GOOD");
    parameters.put("case2", "BETTER");
    final CtType<?> aEnumModel = launcher.getFactory().Type().get(AnEnumModel.class);
    CtEnum<?> genEnum = (CtEnum<?>) Substitution.createTypeFromTemplate("generated.GenEnum", aEnumModel, parameters);
    assertNotNull(genEnum);
    assertSame(genEnum, factory.Type().get("generated.GenEnum"));
    assertEquals(2, genEnum.getEnumValues().size());
    assertEquals("GOOD", genEnum.getEnumValues().get(0).getSimpleName());
    assertEquals("BETTER", genEnum.getEnumValues().get(1).getSimpleName());
}