org.eclipse.ajdt.core.tests/src/org/eclipse/ajdt/core/tests/codeconversion/AspectsConvertingParserTest.java

/*******************************************************************************
 * Copyright (c) 2005, 2008 IBM Corporation, SpringSource and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Matt Chapman  - initial version
 *     Andrew Eisenberg - MockITDConvertingParser and more tests
 *******************************************************************************/
package org.eclipse.ajdt.core.tests.codeconversion;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import org.eclipse.ajdt.core.AspectJCore;
import org.eclipse.ajdt.core.codeconversion.AspectsConvertingParser;
import org.eclipse.ajdt.core.codeconversion.ConversionOptions;
import org.eclipse.ajdt.core.tests.AJDTCoreTestCase;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.CompilationUnit;

public class AspectsConvertingParserTest extends AJDTCoreTestCase {

	public void testBug110751() {
		String source = "public aspect Aspect {\n" //$NON-NLS-1$
				+ "	private void Cloneable.loop(Object[] objects) throws IOException {\n" //$NON-NLS-1$
				+ "		for (Object obj : objects) {\n" //$NON-NLS-1$
				+ "			obj.toString();\n" //$NON-NLS-1$
				+ "		}\n" //$NON-NLS-1$
				+ "	}\n" //$NON-NLS-1$
				+ "};\n"; //$NON-NLS-1$
		ConversionOptions conversionOptions = ConversionOptions.STANDARD;
		AspectsConvertingParser conv = new AspectsConvertingParser(source
				.toCharArray());
		conv.convert(conversionOptions);
		String converted = new String(conv.content);
		assertTrue("Parser failed to handle enhanced for loop", //$NON-NLS-1$
				converted.indexOf("for (Object obj : objects)")!=-1); //$NON-NLS-1$
	}
	
	public void testBug118052() {
		String source = "public aspect Aspect pertypewithin(type_pattern){\n" //$NON-NLS-1$
				+ "	public static void main(String[] args) {\n" //$NON-NLS-1$
				+ "	}\n" //$NON-NLS-1$
				+ "};\n"; //$NON-NLS-1$
		ConversionOptions conversionOptions = ConversionOptions.STANDARD;
		AspectsConvertingParser conv = new AspectsConvertingParser(source
				.toCharArray());
		conv.convert(conversionOptions);
		String converted = new String(conv.content);
		assertTrue("Parser failed to handle pertypewithin", //$NON-NLS-1$
				converted.indexOf("pertypewithin")==-1); //$NON-NLS-1$
	}
	
	public void testBug134343() {
		String source = "public aspect Aspect {\n" //$NON-NLS-1$
				+ "	   declare parents : foo.inspector..* &&\n" //$NON-NLS-1$
				+ " (junit.framework.TestCase+ || *..Test*\n" //$NON-NLS-1$
    		    + " ||foo.inspector.test..*) implements Serializable;\n" //$NON-NLS-1$
				+ "};\n"; //$NON-NLS-1$
		ConversionOptions conversionOptions = ConversionOptions.STANDARD;
		AspectsConvertingParser conv = new AspectsConvertingParser(source
				.toCharArray());
		conv.convert(conversionOptions);
		String converted = new String(conv.content);
		assertTrue("Parser should not have considered Test as an import", //$NON-NLS-1$
				converted.indexOf("Test x") == -1); //$NON-NLS-1$
		assertTrue("Parser should not have considered TestCase as an import", //$NON-NLS-1$
				converted.indexOf("TestCase x") == -1); //$NON-NLS-1$
	}
	
	/**
	 * ensure that the RHS of an assignment is not processed as a potential ITD
	 * eg- int x = Foo.y;  should not be converted into int x = Foo$y;
	 */
	public void testRHS() {
	    String source =   "aspect Aspect { int x = Foo.y; }";
	    String expected = "class  Aspect { int x = Foo.y; }";
	    
        ConversionOptions conversionOptions = ConversionOptions.STANDARD;
        AspectsConvertingParser conv = new AspectsConvertingParser(source
                .toCharArray());
        conv.convert(conversionOptions);
        String converted = new String(conv.content);
        assertEquals("Improperly converted", expected, converted); //$NON-NLS-1$
	}
	
	
	/**
	 * test that ':' are properly handled in switch statements
	 */
    public void testBug260914() {
        String source =   "aspect Aspect { pointcut foo() : execution(); \n void doNothing() { char i = 'o'; switch(i) { case 'o': break; default: break; } }}";
        String expected = "class  Aspect { pointcut foo()              ; \n void doNothing() { char i = 'o'; switch(i) { case 'o': break; default: break; } }}";
        
        ConversionOptions conversionOptions = ConversionOptions.STANDARD;
        AspectsConvertingParser conv = new AspectsConvertingParser(source
                .toCharArray());
        conv.convert(conversionOptions);
        String converted = new String(conv.content);
        assertEquals("Improperly converted", expected, converted); //$NON-NLS-1$
    }
    
    /**
     * test that '?' in type parameters are converted correctly
     */
    public void testBug282948() throws Exception {
        IProject bug282948 = createPredefinedProject("Bug282948");
        IFile file = bug282948.getFile("src/RR.aj");
        String source =   getContents(file);
        
        ConversionOptions conversionOptions = ConversionOptions.STANDARD;
        AspectsConvertingParser conv = new AspectsConvertingParser(source
                .toCharArray());
        conv.convert(conversionOptions);
        String converted = new String(conv.content);
        
        // now convert using a regular Java parser:
        ASTParser parser = ASTParser.newParser(AST.JLS3);
        parser.setSource(converted.toCharArray());
        CompilationUnit result = (CompilationUnit) parser.createAST(null);
        if (result.getProblems().length > 0) {
            fail("Improperly converted.  Original:\n" + source + "\nConverted:\n" + converted); //$NON-NLS-1$
        }
    }

	
	/**
	 * inserts arbitrary conversion text at the proper places in the code
	 * @author andrew
	 *
	 */
    class MockITDConvertingParser extends AspectsConvertingParser {
        public MockITDConvertingParser(char[] content) {
            super(content);
        }

        protected char[] getInterTypeDecls(char[] currentTypeName) {
            return "Here I am!".toCharArray();
        }
    };
    class MockDeclareConvertingParser extends AspectsConvertingParser {
        public MockDeclareConvertingParser(char[] content) {
            super(content);
        }

        public char[] createImplementExtendsITDs(char[] typeName) {
            return "Here I am!".toCharArray();
        }
    };


	
	/**
	 * test that ITD insertions appear in the right place
	 */
	public void testITDInsertions() {
        char[] contents = "public class Foo { aspect Bar { interface X { } } } @interface Y { } ".toCharArray();
        char[] expectedContents = "public class Foo {Here I am! class  Bar {Here I am! interface X {Here I am! } } } @interface Y {Here I am! } ".toCharArray();
	    
        AspectsConvertingParser parser = new MockITDConvertingParser(contents);

	    parser.convert(ConversionOptions.CODE_COMPLETION);
	    char[] convertedContents = parser.content;
        System.out.println(new String(convertedContents));
        System.out.println(new String(expectedContents));
	    assertEquals(new String(expectedContents), new String(convertedContents));
	}
	
	
	
    public void testSuperTypeInsertionsNoExistingClause() {
        char[] contents = "public class Foo { aspect Bar { interface X { } } } @interface Y { } ".toCharArray();
        char[] expectedContents = "public Here I am!{ Here I am!{ Here I am!{ } } } @Here I am!{ } ".toCharArray();

        AspectsConvertingParser parser = new MockDeclareConvertingParser(contents);
        parser.convert(ConversionOptions.CODE_COMPLETION);
        char[] convertedContents = parser.content;
        assertEquals(new String(expectedContents), new String(convertedContents));
    }
    public void testSuperTypeInsertionsExtendsExistingClause() {
        char[] contents = "public class Foo extends X { aspect Bar extends X { interface X extends Y, Z { } } } @interface Z { } ".toCharArray();
        char[] expectedContents = "public Here I am!{ Here I am!{ Here I am!{ } } } @Here I am!{ } ".toCharArray();

        AspectsConvertingParser parser = new MockDeclareConvertingParser(contents);
        parser.convert(ConversionOptions.CODE_COMPLETION);
        char[] convertedContents = parser.content;
        assertEquals(new String(expectedContents), new String(convertedContents));
    }
    public void testSuperTypeInsertionsImplementsExistingClause() {
        char[] contents = "public class Foo implements X{ aspect Bar implements X{ interface X extends X, Y{ } } } @interface Z{ } ".toCharArray();
        char[] expectedContents = "public Here I am!{ Here I am!{ Here I am!{ } } } @Here I am!{ } ".toCharArray();

        AspectsConvertingParser parser = new MockDeclareConvertingParser(contents);
        parser.convert(ConversionOptions.CODE_COMPLETION);
        char[] convertedContents = parser.content;
        assertEquals(new String(expectedContents), new String(convertedContents));
    }
    public void testSuperTypeInsertionsExtendsAndImplementsExistingClause() {
        char[] contents = "public class Foo extends X implements Y { aspect Bar extends X implements Y, B { interface X extends X, A, B { } } } @interface Z{ }".toCharArray();
        char[] expectedContents = "public Here I am!{ Here I am!{ Here I am!{ } } } @Here I am!{ }".toCharArray();

        AspectsConvertingParser parser = new MockDeclareConvertingParser(contents);
        parser.convert(ConversionOptions.CODE_COMPLETION);
        char[] convertedContents = parser.content;
        assertEquals(new String(expectedContents), new String(convertedContents));
    }
    
    public void testBug273914() throws Exception {
        IProject project = createPredefinedProject("Bug273914");
        IFile file = project.getFile("src/DeclaresITDs.aj");
        ICompilationUnit unit = (ICompilationUnit) AspectJCore.create(file);
        String contents = getContents(file);
        AspectsConvertingParser parser = new AspectsConvertingParser(contents.toCharArray());
        parser.setUnit(unit);
        parser.convert(ConversionOptions.CODE_COMPLETION);
        String convertedContents = new String(parser.content);
        assertTrue("Incorrect extends/implements clause for class A\n" + convertedContents, convertedContents.indexOf("class A {") != -1); 
        assertTrue("Incorrect extends/implements clause for interface B\n" + convertedContents, convertedContents.indexOf("interface B {") != -1); 
        assertTrue("Incorrect extends/implements clause for class W\n" + convertedContents, convertedContents.indexOf("class W extends A {") != -1); 
        assertTrue("Incorrect extends/implements clause for interface X\n" + convertedContents, convertedContents.indexOf("interface X {") != -1); 
        assertTrue("Incorrect extends/implements clause for class Y\n" + convertedContents, convertedContents.indexOf("class Y extends DeclaresITDs.W implements DeclaresITDs.X, B {") != -1); 
        assertTrue("Incorrect extends/implements clause for interface Z\n" + convertedContents, convertedContents.indexOf("interface Z extends DeclaresITDs.X, B {") != -1); 
        assertTrue("Incorrect extends/implements clause for class C\n" + convertedContents, convertedContents.indexOf("class C extends DeclaresITDs.W implements DeclaresITDs.X, DeclaresITDs.B {") != -1); 
        assertTrue("Incorrect extends/implements clause for interface D\n" + convertedContents, convertedContents.indexOf("interface D extends DeclaresITDs.X {") != -1); 
        
    }
    
    private String getContents(IFile javaFile) throws CoreException, IOException {
        InputStream is = javaFile.getContents();
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        StringBuffer buffer= new StringBuffer();
        char[] readBuffer= new char[2048];
        int n= br.read(readBuffer);
        while (n > 0) {
            buffer.append(readBuffer, 0, n);
            n= br.read(readBuffer);
        }
        return buffer.toString();
    }

}