001: /*******************************************************************************
002: * Copyright (c) 2005, 2007 BEA Systems, Inc.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *******************************************************************************/package org.eclipse.jdt.apt.tests.annotations.mirrortest;
008:
009: import java.util.Collection;
010: import java.util.Set;
011:
012: import org.eclipse.jdt.apt.tests.annotations.BaseFactory;
013: import org.eclipse.jdt.apt.tests.annotations.BaseProcessor;
014:
015: import com.sun.mirror.apt.AnnotationProcessor;
016: import com.sun.mirror.apt.AnnotationProcessorEnvironment;
017: import com.sun.mirror.declaration.AnnotationTypeDeclaration;
018: import com.sun.mirror.declaration.ClassDeclaration;
019: import com.sun.mirror.declaration.ConstructorDeclaration;
020: import com.sun.mirror.declaration.FieldDeclaration;
021: import com.sun.mirror.declaration.MethodDeclaration;
022: import com.sun.mirror.declaration.TypeDeclaration;
023:
024: public class ASTBasedMirrorDeclarationProcessorFactory extends
025: BaseFactory {
026: public ASTBasedMirrorDeclarationProcessorFactory() {
027: super ("test.DeclarationAnno");
028: }
029:
030: public AnnotationProcessor getProcessorFor(
031: Set<AnnotationTypeDeclaration> arg0,
032: AnnotationProcessorEnvironment env) {
033: return new ASTBasedMirrorDeclarationProcessor(env);
034: }
035:
036: public static final class ASTBasedMirrorDeclarationProcessor extends
037: BaseProcessor {
038:
039: public ASTBasedMirrorDeclarationProcessor(
040: AnnotationProcessorEnvironment env) {
041: super (env);
042: }
043:
044: public void process() {
045: final Collection<TypeDeclaration> typeDecls = _env
046: .getTypeDeclarations();
047: boolean done = false;
048: for (TypeDeclaration typeDecl : typeDecls) {
049: if (typeDecl instanceof ClassDeclaration) {
050: examineClass((ClassDeclaration) typeDecl);
051: if (typeDecl.getQualifiedName().equals("test.Foo"))
052: done = true;
053: }
054: }
055: // if the current file does not contain "test.Foo",
056: // look for it by name and run the same tests.
057: if (!done) {
058: final ClassDeclaration fooDecl = (ClassDeclaration) _env
059: .getTypeDeclaration("test.Foo");
060: examineClass(fooDecl);
061: final ClassDeclaration innerTypeDecl = (ClassDeclaration) _env
062: .getTypeDeclaration("test.Foo$Inner");
063: examineClass(innerTypeDecl);
064: }
065: }
066:
067: private void examineClass(ClassDeclaration typeDecl) {
068:
069: assertNonNull(typeDecl, "missing type declaration");
070: if (typeDecl != null) {
071: final String typename = typeDecl.getSimpleName();
072: if (typename.equals("Foo")) {
073: final Collection<? extends MethodDeclaration> methods = typeDecl
074: .getMethods();
075: assertEqual(2, methods.size(),
076: "number of methods do not match ");
077: for (MethodDeclaration method : methods) {
078: final String name = method.getSimpleName();
079: if (name.equals("getType")) {
080: final String methodString = method
081: .toString();
082: final String expectedString = "UnknownType getType()";
083: assertEqual(expectedString, methodString,
084: "signature mismatch");
085: } else if (name.equals("voidMethod")) {
086: final String methodString = method
087: .toString();
088: final String expectedString = "void voidMethod()";
089: assertEqual(expectedString, methodString,
090: "signature mismatch");
091: } else {
092: assertEqual(null, method.toString(),
093: "unexpected method");
094: }
095: }
096:
097: final Collection<ConstructorDeclaration> constructors = typeDecl
098: .getConstructors();
099: assertEqual(1, constructors.size(),
100: "number of constructors do not match");
101: for (ConstructorDeclaration constructor : constructors) {
102: final String constructorString = constructor
103: .toString();
104: final String expectedString = " Foo(type)";
105: assertEqual(expectedString, constructorString,
106: "signature mismatch");
107: }
108: final Collection<FieldDeclaration> fields = typeDecl
109: .getFields();
110: assertEqual(2, fields.size(),
111: "number of fields do not match");
112: for (FieldDeclaration field : fields) {
113: final String name = field.getSimpleName();
114: if ("field0".equals(name)
115: || "field1".equals(name)) {
116: continue;
117: }
118: assertEqual(null, name, "unexpected field");
119: }
120: } else if (typename.equals("Inner")) {
121: final Collection<? extends MethodDeclaration> methods = typeDecl
122: .getMethods();
123: assertEqual(0, methods.size(),
124: "number of methods do not match ");
125:
126: final Collection<ConstructorDeclaration> constructors = typeDecl
127: .getConstructors();
128: assertEqual(1, constructors.size(),
129: "number of constructors do not match");
130: for (ConstructorDeclaration constructor : constructors) {
131: final String constructorString = constructor
132: .toString();
133: final String expectedString = "Inner()";
134: assertEqual(expectedString, constructorString,
135: "signature mismatch");
136: }
137: final Collection<FieldDeclaration> fields = typeDecl
138: .getFields();
139: assertEqual(0, fields.size(),
140: "number of fields do not match");
141: }
142: }
143: }
144: }
145: }
|