1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/*******************************************************************************
* Copyright (c) 2005, 2008 BEA Systems, Inc.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*******************************************************************************/
package org.eclipse.jdt.apt.tests.annotations.mirrortest;
import java.util.Collection;
import java.util.Set;
import org.eclipse.jdt.apt.tests.annotations.BaseFactory;
import org.eclipse.jdt.apt.tests.annotations.BaseProcessor;
import com.sun.mirror.apt.AnnotationProcessor;
import com.sun.mirror.apt.AnnotationProcessorEnvironment;
import com.sun.mirror.declaration.AnnotationTypeDeclaration;
import com.sun.mirror.declaration.ClassDeclaration;
import com.sun.mirror.declaration.ConstructorDeclaration;
import com.sun.mirror.declaration.FieldDeclaration;
import com.sun.mirror.declaration.MethodDeclaration;
import com.sun.mirror.declaration.TypeDeclaration;
public class ASTBasedMirrorDeclarationProcessorFactory
extends BaseFactory
{
public ASTBasedMirrorDeclarationProcessorFactory(){
super("test.DeclarationAnno");
}
public AnnotationProcessor getProcessorFor(
Set<AnnotationTypeDeclaration> arg0,
AnnotationProcessorEnvironment env) {
return new ASTBasedMirrorDeclarationProcessor(env);
}
public static final class ASTBasedMirrorDeclarationProcessor
extends BaseProcessor{
public ASTBasedMirrorDeclarationProcessor(AnnotationProcessorEnvironment env){
super(env);
}
public void process() {
final Collection<TypeDeclaration> typeDecls = _env.getTypeDeclarations();
boolean done = false;
for( TypeDeclaration typeDecl : typeDecls ){
if(typeDecl instanceof ClassDeclaration ){
examineClass( (ClassDeclaration)typeDecl );
if( typeDecl.getQualifiedName().equals("test.Foo") )
done = true;
}
}
// if the current file does not contain "test.Foo",
// look for it by name and run the same tests.
if( !done ){
final ClassDeclaration fooDecl = (ClassDeclaration)_env.getTypeDeclaration("test.Foo");
examineClass(fooDecl);
final ClassDeclaration innerTypeDecl = (ClassDeclaration)_env.getTypeDeclaration("test.Foo$Inner");
examineClass(innerTypeDecl);
}
}
private void examineClass(ClassDeclaration typeDecl ){
assertNonNull(typeDecl, "missing type declaration");
if( typeDecl != null ){
final String typename = typeDecl.getSimpleName();
if(typename.equals("Foo")){
final Collection<? extends MethodDeclaration> methods = typeDecl.getMethods();
assertEqual(2, methods.size(), "number of methods do not match ");
for(MethodDeclaration method : methods ){
final String name = method.getSimpleName();
if( name.equals("getType") ){
final String methodString = method.toString();
final String expectedString = "UnknownType getType()";
assertEqual(expectedString, methodString, "signature mismatch");
}
else if( name.equals("voidMethod")){
final String methodString = method.toString();
final String expectedString = "void voidMethod()";
assertEqual(expectedString, methodString, "signature mismatch");
}
else{
assertEqual(null, method.toString(), "unexpected method");
}
}
final Collection<ConstructorDeclaration> constructors =
typeDecl.getConstructors();
assertEqual(1, constructors.size(), "number of constructors do not match");
for( ConstructorDeclaration constructor : constructors ){
final String constructorString = constructor.toString();
final String expectedString = "Foo(UnknownType type)";
assertEqual(expectedString, constructorString, "signature mismatch");
}
final Collection<FieldDeclaration> fields =
typeDecl.getFields();
assertEqual(2, fields.size(), "number of fields do not match");
for( FieldDeclaration field : fields ){
final String name = field.getSimpleName();
if( "field0".equals(name) || "field1".equals(name) ){
continue;
}
assertEqual(null, name, "unexpected field");
}
}
else if(typename.equals("Inner")){
final Collection<? extends MethodDeclaration> methods =
typeDecl.getMethods();
assertEqual(0, methods.size(), "number of methods do not match ");
final Collection<ConstructorDeclaration> constructors =
typeDecl.getConstructors();
assertEqual(1, constructors.size(), "number of constructors do not match");
for( ConstructorDeclaration constructor : constructors ){
final String constructorString = constructor.toString();
final String expectedString = "Inner()";
assertEqual(expectedString, constructorString, "signature mismatch");
}
final Collection<FieldDeclaration> fields =
typeDecl.getFields();
assertEqual(0, fields.size(), "number of fields do not match");
}
}
}
}
}
|
