--- /dev/null
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package spechelper;
+
+import org.eclipse.jdt.core.Flags;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.ITypeParameter;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.ASTParser;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.Expression;
+import org.eclipse.jdt.core.dom.ITypeBinding;
+import org.eclipse.jdt.core.dom.SingleMemberAnnotation;
+import org.eclipse.jdt.internal.ui.JavaPlugin;
+import org.eclipse.jdt.ui.JavaElementLabelProvider;
+import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.dialogs.ElementListSelectionDialog;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ */
+public class MethodSelector {
+
+ public String obtainReplacement(String buffer) {
+ IMethod method = selectMethod();
+ // if user did cancel the selection
+ if (method == null) {
+ return null;
+ }
+
+ // see if we are already in a annotation:
+ // if yes -> only dump the testtarget annotation, not the complete
+ // TestInfo
+ // (could not easily find this out with CompilationUnit, since inserting
+ // a :
+ // broke the AST - maybe use WorkingCopy and so on,
+ // but for now: do it with simple String analysis
+ boolean shortOnly = false;
+ int annotPos = buffer.lastIndexOf("@TestInfo");
+ // the latest annotation - count "(" ")" pairs - if not the same count
+ // we assume to be in the annotation (H: code compiles fine)
+ if (annotPos != -1) {
+ String sub = buffer.substring(annotPos);
+ // only consider the latest 6 lines for the annotation to occur
+ // (6 = range within which the annotation @TestTarget
+ // must occur, but out of range to reach the annotation from the
+ // previous method - ah i'd prefer working with compilationUnit...
+ String[] lines = sub.split("\n");
+ for (int i = lines.length - 6; i < lines.length; i++) {
+ String line = lines[i];
+ if (line.contains("@TestTarget")) {
+ shortOnly = true;
+ }
+ }
+ }
+
+ return generateAnnotation(shortOnly, method);
+ }
+
+
+ private String generateAnnotation(boolean shortOnly, IMethod method) {
+ String[] ptypes = method.getParameterTypes();
+ String param = "";
+ for (int i = 0; i < ptypes.length; i++) {
+ String ptype = ptypes[i];
+ String sig = Signature.toString(ptype);
+ // kind of a hack: convert all Generic Type args to Object, or to
+ // its bound Type
+ if (sig.length() == 1) {
+ ITypeParameter tps = method.getTypeParameter(sig);
+ sig = "Object";
+
+ if (tps != null && tps.exists()) {
+ try {
+ String[] bounds = tps.getBounds();
+ if (bounds.length > 0) {
+ sig = bounds[0];
+ }
+ } catch (JavaModelException e) {
+ e.printStackTrace();
+ }
+
+ }
+ }
+ // omit type signature
+ sig = sig.replaceAll("<.*>", "");
+ param += (i > 0 ? ", " : "") + sig + ".class";
+ }
+ String IND = " ";
+
+ String targ = "@TestTarget(\n" + IND + " methodName = \""
+ + method.getElementName() + "\",\n" + IND
+ + " methodArgs = {" + param + "}\n" + IND + " )\n";
+
+ String s;
+ if (shortOnly) {
+ s = targ;
+ } else {
+
+ s = "@TestInfo(\n" + IND + " status = TestStatus.TBR,\n" + IND
+ + " notes = \"\",\n" + IND + " targets = {\n" + IND
+ + " " + targ + IND + "})";
+ }
+ return s;
+ }
+
+ private IMethod selectMethod() {
+ IEditorPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow()
+ .getActivePage().getActiveEditor();
+ Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow()
+ .getShell();
+ IEditorInput ei = part.getEditorInput();
+ final ICompilationUnit cu = JavaPlugin.getDefault()
+ .getWorkingCopyManager().getWorkingCopy(ei);
+ // cu != null since we register only for java/javadoc completion
+ // proposals
+ ASTParser parser = ASTParser.newParser(AST.JLS3);
+ parser.setSource(cu);
+ parser.setResolveBindings(true);
+ CompilationUnit unit = (CompilationUnit) parser.createAST(null);
+
+ class MHolder {
+ IMethod method;
+ }
+ final MHolder mholder = new MHolder();
+
+ class FHolder {
+ boolean foundClassAnnotation;
+ }
+ final FHolder fholder = new FHolder();
+
+ unit.accept(new ASTVisitor() {
+ public boolean visit(SingleMemberAnnotation node) {
+ String name = node.getTypeName().getFullyQualifiedName();
+ if (!name.equals("TestTargetClass")) {
+ return false;
+ }
+ fholder.foundClassAnnotation = true;
+ Expression targetClassE = node.getValue();
+ ITypeBinding ty = targetClassE.resolveTypeBinding();
+ if (ty == null) {
+ return false;
+ }
+ ITypeBinding[] classTypes = ty.getTypeArguments();
+ if (classTypes.length > 0) {
+ ITypeBinding tp = classTypes[0];
+ String qname = tp.getQualifiedName();
+ System.out.println("qname:" + qname);
+ IJavaProject myProject = cu.getJavaProject();
+ try {
+ IType myType = myProject.findType(qname);
+ if (myType != null) {
+ Shell parent = PlatformUI.getWorkbench()
+ .getActiveWorkbenchWindow().getShell();
+ ElementListSelectionDialog dialog = new ElementListSelectionDialog(
+ parent,
+ new JavaElementLabelProvider(
+ JavaElementLabelProvider.SHOW_PARAMETERS
+ | JavaElementLabelProvider.SHOW_OVERLAY_ICONS
+ | JavaElementLabelProvider.SHOW_RETURN_TYPE));
+ // restrict to public/protected methods only
+ IMethod[] allMeth = myType.getMethods();
+ List<IMethod> pubproMethods = new ArrayList<IMethod>();
+ for (int i = 0; i < allMeth.length; i++) {
+ IMethod method = allMeth[i];
+ if ((method.getFlags() & (Flags.AccPublic | Flags.AccProtected)) != 0) {
+ pubproMethods.add(method);
+ }
+ }
+ IMethod[] res = pubproMethods
+ .toArray(new IMethod[pubproMethods.size()]);
+ dialog.setIgnoreCase(true);
+ dialog.setBlockOnOpen(true);
+ dialog.setElements(res);//
+ dialog.setFilter("");
+ dialog.setTitle(qname);
+ if (dialog.open() != IDialogConstants.CANCEL_ID) {
+ Object[] types = dialog.getResult();
+ System.out.println("selected:" + types[0]);
+ IMethod method = (IMethod) types[0];
+ mholder.method = method;
+
+ } else {
+ // System.out.println("cancelled!!");
+ }
+ }
+ } catch (JavaModelException e) {
+ e.printStackTrace();
+ }
+ }
+ return true;
+ }
+ });
+ if (!fholder.foundClassAnnotation) {
+ MessageDialog.openInformation(shell, "Class Annotation missing",
+ "@TestTargetClass(...) is missing");
+ return null;
+ }
+ return mholder.method;
+ }
+}
OSDN Git Service
