Attachment 49025 Details for Bug 155550 – JUnit Plug-in Test to re-create problem

JUnit Plug-in Test to re-create problem

ScratchTest.java (text/plain), 10.04 KB, created by Brian Vosburgh

on 2006-08-29 21:16:30 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Brian Vosburgh

Created: 2006-08-29 21:16:30 EDT

Size: 10.04 KB

patch

obsolete

>package org.eclipse.dali.core.tests.adapters.java;
>
>import java.lang.reflect.Array;
>import java.util.Iterator;
>import java.util.List;
>
>import org.eclipse.core.resources.IContainer;
>import org.eclipse.core.resources.IFolder;
>import org.eclipse.core.resources.IProject;
>import org.eclipse.core.resources.IProjectDescription;
>import org.eclipse.core.resources.ResourcesPlugin;
>import org.eclipse.core.runtime.CoreException;
>import org.eclipse.core.runtime.IPath;
>import org.eclipse.core.runtime.Path;
>import org.eclipse.jdt.core.IClasspathEntry;
>import org.eclipse.jdt.core.ICompilationUnit;
>import org.eclipse.jdt.core.IField;
>import org.eclipse.jdt.core.IJavaProject;
>import org.eclipse.jdt.core.IPackageFragment;
>import org.eclipse.jdt.core.IPackageFragmentRoot;
>import org.eclipse.jdt.core.IType;
>import org.eclipse.jdt.core.JavaCore;
>import org.eclipse.jdt.core.JavaModelException;
>import org.eclipse.jdt.core.dom.AST;
>import org.eclipse.jdt.core.dom.ASTParser;
>import org.eclipse.jdt.core.dom.CompilationUnit;
>import org.eclipse.jdt.core.dom.FieldDeclaration;
>import org.eclipse.jdt.core.dom.IExtendedModifier;
>import org.eclipse.jdt.core.dom.TypeDeclaration;
>import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
>import org.eclipse.jdt.launching.JavaRuntime;
>
>import junit.framework.TestCase;
>
>public class ScratchTest extends TestCase {
>	private IProject project;
>	private IJavaProject javaProject;
>	private IPackageFragmentRoot sourceFolder;
>
>	public ScratchTest() {
>		super();
>	}
>
>	public ScratchTest(String name) {
>		super(name);
>	}
>
>	protected void setUp() throws Exception {
>		super.setUp();
>		this.project = this.buildProject();
>		this.addJavaNature();
>		this.javaProject = this.createJavaProject();
>		this.sourceFolder = this.createSourceFolder();
>		this.addSystemLibraryClasspathEntry();
>		this.addSourceFolderClasspathEntry();
>	}
>
>	private IProject buildProject() throws CoreException {
>		IProject p = ResourcesPlugin.getWorkspace().getRoot().getProject("Test Project");
>		p.create(null);
>		p.open(null);
>		return p;
>	}
>
>	protected void tearDown() throws Exception {
>		this.project.delete(true, true, null);
>		this.sourceFolder = null;
>		this.javaProject = null;
>		this.project = null;
>		super.tearDown();
>	}
>
>	public void addProjectNature(String natureID) throws CoreException {
>		IProjectDescription description = this.project.getDescription();
>		description.setNatureIds((String[]) this.add(description.getNatureIds(), natureID));
>		this.project.setDescription(description, null);
>	}
>
>	public void removeProjectNature(String natureID) throws CoreException {
>		IProjectDescription description = this.project.getDescription();
>		description.setNatureIds((String[]) this.removeAllOccurrences(description.getNatureIds(), natureID));
>		this.project.setDescription(description, null);
>	}
>
>	public Object[] add(Object[] array, Object o) {
>		int len = array.length;
>		Object[] result = (Object[]) Array.newInstance(array.getClass().getComponentType(), len + 1);
>		System.arraycopy(array, 0, result, 0, len);
>		result[len] = o;
>		return result;
>	}
>
>	public Object[] removeAllOccurrences(Object[] array, Object value) {
>		Object[] result = array;
>		if (value == null) {
>			for (int i = array.length; i-- > 0; ) {
>				if (array[i] == null) {
>					result = this.remove(result, null);
>				}
>			}
>		} else {
>			for (int i = array.length; i-- > 0; ) {
>				if (value.equals(array[i])) {
>					result = this.remove(result, value);
>				}
>			}
>		}
>		return result;
>	}
>	
>	public Object[] remove(Object[] array, Object value) {
>		int index = this.indexOf(array, value);
>		int len = array.length;
>		Object[] result = (Object[]) Array.newInstance(array.getClass().getComponentType(), len - 1);
>		System.arraycopy(array, 0, result, 0, index);
>		System.arraycopy(array, index + 1, result, index, len - index - 1);
>		return result;
>	}
>	
>	public int indexOf(Object[] array, Object o) {
>		int len = array.length;
>		if (o == null) {
>			for (int i = 0; i < len; i++) {
>				if (array[i] == null) {
>					return i;
>				}
>			}
>		} else {
>			for (int i = 0; i < len; i++) {
>				if (o.equals(array[i])) {
>					return i;
>				}
>			}
>		}
>		return -1;
>	}
>	
>	private void addJavaNature() throws CoreException {
>		this.addProjectNature(JavaCore.NATURE_ID);
>	}
>
>	private IJavaProject createJavaProject() throws CoreException {
>		IJavaProject jp = JavaCore.create(this.project);
>		jp.setRawClasspath(new IClasspathEntry[0], null);
>		jp.setOutputLocation(this.createFolder("bin").getFullPath(), null);
>		jp.setOption(JavaCore.COMPILER_COMPLIANCE, JavaCore.VERSION_1_5);
>		jp.setOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaCore.VERSION_1_5);
>		jp.setOption(JavaCore.COMPILER_SOURCE, JavaCore.VERSION_1_5);
>		return jp;
>	}
>	
>	private IPackageFragmentRoot createSourceFolder() throws CoreException {
>		return this.javaProject.getPackageFragmentRoot(this.createFolder("src"));
>	}
>	
>	private void addSystemLibraryClasspathEntry() throws JavaModelException {
>		this.addClasspathEntry(JavaRuntime.getDefaultJREContainerEntry());
>	}
>	
>	private void addSourceFolderClasspathEntry() throws JavaModelException {
>		this.addClasspathEntry(JavaCore.newSourceEntry(this.sourceFolder.getPath()));
>	}
>	
>	private void addClasspathEntry(IClasspathEntry entry) throws JavaModelException {
>		this.javaProject.setRawClasspath((IClasspathEntry[]) this.add(this.javaProject.getRawClasspath(), entry), null);
>	}
>	
>	public IFolder createFolder(String folderName) throws CoreException {
>		return this.createFolder(this.project, new Path(folderName));
>	}
>
>	public IFolder createFolder(IContainer container, String folderName) throws CoreException {
>		return this.createFolder(container, new Path(folderName));
>	}
>	
>	public IFolder createFolder(IContainer container, IPath folderPath) throws CoreException {
>		IFolder folder = container.getFolder(folderPath);
>		if ( ! folder.exists()) {
>			folder.create(false, true, null);
>		}
>		return folder;
>	}
>	
>	protected static final String CR = System.getProperty("line.separator");
>
>	protected void buildType(String annotationSource) throws CoreException {
>		this.createType("test", "TestClass.java", this.buildTypeSource(annotationSource));
>	}
>
>	public IType createType(String packageName, String compilationUnitName, String source) throws CoreException {
>		return this.createType(this.createPackage(packageName), compilationUnitName, source);
>	}
>
>	public IPackageFragment createPackage(String packageName) throws CoreException {
>		return this.sourceFolder.createPackageFragment(packageName, false, null);
>	}
>
>	public IType createType(IPackageFragment packageFragment, String compilationUnitName, String source) throws CoreException {
>		StringBuffer sb = new StringBuffer(source.length() + 200);
>		sb.append("package ").append(packageFragment.getElementName()).append(CR);
>		sb.append(CR);
>		sb.append(source);
>		ICompilationUnit cu = packageFragment.createCompilationUnit(compilationUnitName, sb.toString(), false, null);
>		return cu.findPrimaryType();
>	}
>
>	protected String buildTypeSource(String annotationSource) {
>		StringBuffer sb = new StringBuffer(2000);
>		sb.append(CR);
>		sb.append("public class TestClass {").append(CR);
>		sb.append(CR);
>		sb.append("    ").append(annotationSource).append(CR);
>		sb.append("    private int id;").append(CR);
>		sb.append(CR);
>		sb.append("    public int getId() {").append(CR);
>		sb.append("        return this.id;").append(CR);
>		sb.append("    }").append(CR);
>		sb.append(CR);
>		sb.append("    public void setId(int id) {").append(CR);
>		sb.append("        this.id = id;").append(CR);
>		sb.append("    }").append(CR);
>		sb.append(CR);
>		sb.append("}").append(CR);
>		return sb.toString();
>	}
>
>	protected IType type() throws JavaModelException {
>		return this.javaProject.findType("test.TestClass");
>	}
>
>	protected IField field() throws JavaModelException {
>		return this.type().getField("id");
>	}
>
>	public void test1() throws Exception {
>		this.verify("@Foo(value={1, 2})");
>	}
>
>	public void test2() throws Exception {
>		this.verify("@Foo({1, 2})");
>	}
>
>	private void verify(String annotation) throws Exception {
>		this.buildType(annotation);
>		CompilationUnit astRoot = this.astRoot();
>		FieldDeclaration fieldDeclaration = this.fieldDeclaration(astRoot);
>		this.assertContainsAnnotation(fieldDeclaration);
>	}
>
>	private void assertContainsAnnotation(FieldDeclaration fieldDeclaration) {
>		for (Iterator stream = fieldDeclaration.modifiers().iterator(); stream.hasNext(); ) {
>			if (((IExtendedModifier) stream.next()).isAnnotation()) {
>				return;
>			}
>		}
>		fail("missing annotation");
>	}
>
>	public CompilationUnit astRoot() throws JavaModelException {
>		ASTParser parser = ASTParser.newParser(AST.JLS3);
>		IField field = this.field();
>		if (field.isBinary()) {
>			parser.setSource(field.getClassFile());  // the class file must have a source attachment
>		} else {
>			parser.setSource(field.getCompilationUnit());
>		}
>		return (CompilationUnit) parser.createAST(null);  // null = no progress monitor
>	}
>
>	private FieldDeclaration fieldDeclaration(CompilationUnit astRoot) {
>		FieldDeclaration[] fieldDeclarations = this.typeDeclaration(astRoot).getFields();
>		for (int i = fieldDeclarations.length; i-- > 0; ) {
>			FieldDeclaration fieldDeclaration = fieldDeclarations[i];
>			// handle multiple fields declared in a single statement:
>			//     private int foo, bar;
>			List fragments = fieldDeclaration.fragments();
>			for (int j = fragments.size(); j-- > 0; ) {
>				VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(j);
>				if (fragment.getName().getFullyQualifiedName().equals("id")) {
>					return fieldDeclaration;
>				}
>			}
>		}
>		return null;		
>	}
>
>	private TypeDeclaration typeDeclaration(CompilationUnit astRoot) {
>		for (Iterator stream = astRoot.types().iterator(); stream.hasNext(); ) {
>			TypeDeclaration typeDeclaration = (TypeDeclaration) stream.next();
>			if (typeDeclaration.getName().getFullyQualifiedName().equals("TestClass")) {
>				return typeDeclaration;
>			}
>		}
>		return null;
>	}
>	
>}

Actions: View

Attachments on bug 155550: 49025