/*******************************************************************************
 * Copyright (c) 2004, 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:
 *     Luzius Meisser - initial implementation
 *     Andrew Eisenberg - tests for ITD replacement
 *******************************************************************************/
package org.eclipse.ajdt.core.tests.javaelements;

import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.parser.Parser;
import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.ajdt.core.codeconversion.AspectsConvertingParser;
import org.eclipse.ajdt.core.codeconversion.ConversionOptions;

/**
 * 
 * @author Luzius Meisser
 * @author andrew
 */
public class AspectsConvertingParserTest2 extends AbstractTestCase {
	

	/*
	 * @see TestCase#setUp()
	 */
	protected void setUp() throws Exception {
		super.setUp();
		unit.requestOriginalContentMode();
		char[] content = (char[])unit.getContents().clone();
		unit.discardOriginalContentMode();
		myParser = new AspectsConvertingParser(content);

	}

	/*
	 * @see TestCase#tearDown()
	 */
	protected void tearDown() throws Exception {
		super.tearDown();
	}

	public void testConvert() {
//		int len = myParser.content.length;
		
		myParser.convert(ConversionOptions.STANDARD);
//		if (myParser.content.length !=  len + 4)
//			fail("Reference to C has not been added (?).");
		if (new String(myParser.content).indexOf(':') != -1)
			fail("Some pointcut designators have not been removed."); //$NON-NLS-1$
	}
	
	public void testConvert2() {
 		myParser.convert(new ConversionOptions(true, true, false));
 		int pos = new String(myParser.content).indexOf("org.aspectj.lang.JoinPoint thisJoinPoint;"); //$NON-NLS-1$
 		if (pos < 0)
 			fail("tjp has not been added."); //$NON-NLS-1$
 		
 		pos = new String(myParser.content).indexOf("org.aspectj.lang.JoinPoint.StaticPart thisJoinPointStaticPart;"); //$NON-NLS-1$
 		if (pos < 0)
 			fail("tjpsp has not been added."); //$NON-NLS-1$
 		
//		if (myParser.content.length != 1086)
//			fail("tjp and tjpsp have not been added correctly.");
	}
	
	public void testConvert3() {
		int len = myParser.content.length;
 		myParser.convert(ConversionOptions.CONSTANT_SIZE);
		if (myParser.content.length !=  len)
			fail("Length of content has changed."); //$NON-NLS-1$
		if (new String(myParser.content).indexOf(':') != -1)
			fail("Some pointcut designators have not been removed."); //$NON-NLS-1$
	}
	
	public void testConvert4() {
 		myParser.convert(ConversionOptions.CODE_COMPLETION);
		assertEquals("Wrong size of content.",1129,myParser.content.length); //$NON-NLS-1$
		if (new String(myParser.content).indexOf(':') != -1)
			fail("Some pointcut designators have not been removed."); //$NON-NLS-1$
	}

	public void testBug93248() {
		String statement = "System.out.println(true?\"foo\":\"bar\");"; //$NON-NLS-1$
		char[] testContent = ("public aspect ABC {\npublic static void main(String[] args) {\n" //$NON-NLS-1$
				+ statement + "\n}\n}").toCharArray(); //$NON-NLS-1$
		AspectsConvertingParser pars = new AspectsConvertingParser(testContent);
		pars.convert(ConversionOptions.STANDARD);
		String converted = new String(pars.content);
		if (converted.indexOf(statement) == -1) {
			fail("Regression of bug 93248: tertiary operator breaks organise imports"); //$NON-NLS-1$
		}
	}
	
	public void testBug93248again() {
		// nested conditional statements
		String statement = "System.out.println(true?true?\"foo\":\"foobar\":\"bar\");"; //$NON-NLS-1$
		char[] testContent = ("public aspect ABC {\npublic static void main(String[] args) {\n" //$NON-NLS-1$
				+ statement + "\n}\n}").toCharArray(); //$NON-NLS-1$
		AspectsConvertingParser pars = new AspectsConvertingParser(testContent);
		pars.convert(ConversionOptions.STANDARD);
		String converted = new String(pars.content);
		if (converted.indexOf(statement) == -1) {
			fail("Regression of bug 93248: tertiary operator breaks organise imports"); //$NON-NLS-1$
		}
	}	
	
	
	/*
	 * Class under test for int findPrevious(char, char[], int)
	 */
	public void testFindPreviouscharcharArrayint() {
		char[] testContent = "abc abc abc xyz xyz".toCharArray(); //$NON-NLS-1$
		char target = 'b';
		myParser.content = testContent;
		if (myParser.findPrevious(target, 3) != 1)
			fail("Find previous failed."); //$NON-NLS-1$
		if (myParser.findPrevious(target, 0) != -1)
			fail("Find previous failed."); //$NON-NLS-1$
		
	}

	/*
	 * Class under test for int findPrevious(char[], char[], int)
	 */
	public void testFindPreviouscharArraycharArrayint() {
		
		char[] testContent = "abc abc abc xyz xyz".toCharArray(); //$NON-NLS-1$
		char[] target = "bx".toCharArray(); //$NON-NLS-1$
		myParser.content = testContent;
		if (myParser.findPrevious(target, 3) != 1)
			fail("Find previous failed."); //$NON-NLS-1$
		if (myParser.findPrevious(target, 0) != -1)
			fail("Find previous failed."); //$NON-NLS-1$
		if (myParser.findPrevious(target, 13) != 12)
			fail("Find previous failed."); //$NON-NLS-1$
	}

	public void testFindPreviousNonSpace() {
		char[] testContent = "abc abc abc xyz xyz".toCharArray(); //$NON-NLS-1$
		myParser.content = testContent;
		if (myParser.findPreviousNonSpace(3) != 2)
			fail("Find previous failed."); //$NON-NLS-1$
		if (myParser.findPreviousNonSpace(0) != 0)
			fail("Find previous failed, returns " + myParser.findPreviousNonSpace(0)); //$NON-NLS-1$
		
	}

	public void testFindNext() {
		char[] testContent = "abc abc abc xyz xyz".toCharArray(); //$NON-NLS-1$
		char[] target = "bx".toCharArray(); //$NON-NLS-1$
		myParser.content = testContent;
		if (myParser.findNext(target, 0) != 1)
			fail("Find next failed."); //$NON-NLS-1$
		if (myParser.findNext(target, 100) != -1)
			fail("Find next failed."); //$NON-NLS-1$
		if (myParser.findNext(target, 7) != 9)
			fail("Find next failed."); //$NON-NLS-1$
		if (myParser.findNext(target, 17) != -1)
			fail("Find next failed."); //$NON-NLS-1$
		if (myParser.findNext(target, 12) != 12)
			fail("Find next failed."); //$NON-NLS-1$
		
	}
	

    public void testITDReplace1() {
        char[] testContent = "aspect Foo { void foo.bar.Circle<java.util.List<String>>.nothing(h.y.Z f, h.y.Z y) }".toCharArray(); //$NON-NLS-1$
        String target      = "class  Foo { void foo$bar$Circle$java$util$List$String$$$nothing(h.y.Z f, h.y.Z y) }"; //$NON-NLS-1$
        AspectsConvertingParser parser = new AspectsConvertingParser(testContent);
        parser.content = testContent;
        parser.convert(ConversionOptions.CONSTANT_SIZE);
        assertEquals(target, new String(parser.content));
    }
    public void testITDReplace2() {
        char[] testContent = "aspect Foo { void foo .  bar .   Circle <   java .  util  .  List  <  String  >  >  .  nothing(h.y.Z f, h.y.Z y) }".toCharArray(); //$NON-NLS-1$
        String target      = "class  Foo { void foo$$$$bar$$$$$Circle$$$$$java$$$$util$$$$$List$$$$$String$$$$$$$$$$$nothing(h.y.Z f, h.y.Z y) }"; //$NON-NLS-1$
        AspectsConvertingParser parser = new AspectsConvertingParser(testContent);
        parser.content = testContent;
        parser.convert(ConversionOptions.CONSTANT_SIZE);
        assertEquals(target, new String(parser.content));
    }
    public void testITDReplace3() {
        char[] testContent = "aspect Foo { void foo .  bar .   Circle <   java .  util  .  List  <  String  >  >  .  nothing<? extends java.util.List<String> >(h.y.Z f, h.y.Z y) }".toCharArray(); //$NON-NLS-1$
        String target      = "class  Foo { void foo$$$$bar$$$$$Circle$$$$$java$$$$util$$$$$List$$$$$String$$$$$$$$$$$nothing<? extends java.util.List<String> >(h.y.Z f, h.y.Z y) }"; //$NON-NLS-1$
        AspectsConvertingParser parser = new AspectsConvertingParser(testContent);
        parser.content = testContent;
        parser.convert(ConversionOptions.CONSTANT_SIZE);
        assertEquals(target, new String(parser.content));
    }
    
    public void testTypeParamOnLocalVariable1() throws Exception {
        assertConvertingParse(
                "aspect Test {\n" +
        		"  private pointcut none();\n" +
        		"  before(): none() {\n" + 
        		"    Class<?>[] x;\n" + 
                "  }\n" +
                "  before() : none() {}\n" +  
                "}");
    }
    public void testTypeParamOnLocalVariable2() throws Exception {
        assertConvertingParse(
                "aspect Test {\n" +
                "  private pointcut none();\n" +
                "  before(): none() {\n" + 
                "    Class<?>[] x;\n" +
                "    int y = 0;\n" +
                "    if ((y < 8) ? true : false) {} \n" + 
                "  }\n" +
                "  before() : none() {}\n" + 
                "}");
    }
    public void testTypeParamOnLocalVariable3() throws Exception {
        assertConvertingParse(
                "aspect Test {\n" +
                "  private pointcut none();\n" +
                "  before(): none() {\n" + 
                "    Class<?>[] x;\n" +
                "    int Y = 0;\n" +
                "    if ((Y < 8) ? true : false) {} \n" + 
                "  }\n" +
                "  before() : none() {}\n" +  
                "}");
    }
    public void testTypeParamOnLocalVariable4() throws Exception {
        assertConvertingParse(
                "aspect Test {\n" +
                "  private pointcut none();\n" +
                "  before(): none() {\n" + 
                "    Class<?>[] x;\n" +
                "    int Y = 6 < 7 ? 6: 7;\n" +
                "    if ((Y < 8) ? true : false) {} \n" + 
                "  }\n" +
                "  before() : none() {}\n" +  
        "}");
    }
    
    // Bug 384422
    public void testAnnotationStylePointcutInAspect1() throws Exception {
        assertConvertingParse(
                "import org.aspectj.lang.JoinPoint;\n" + 
                "import org.aspectj.lang.annotation.AfterThrowing;\n" + 
                "public aspect Test {\n" + 
                "        @AfterThrowing(pointcut=\"execution(* *(..))\")\n" + 
                "        public void bizLoggerWithException(JoinPoint thisJoinPoint) { }\n" + 
                "}");
    }

    // Bug 384422
    public void testAnnotationStylePointcutInAspect2() throws Exception {
        assertConvertingParse(
                "import org.aspectj.lang.JoinPoint;\n" + 
                "import org.aspectj.lang.annotation.AfterThrowing;\n" + 
                "public aspect Test {\n" + 
                "        @AfterThrowing(throwing=\"e\", pointcut=\"execution(* *(..))\")\n" + 
                "        public void bizLoggerWithException(JoinPoint thisJoinPoint) { }\n" + 
                "}");
    }
    
    // Bug 384422
    public void testAnnotationStylePointcutInAspect3() throws Exception {
        assertConvertingParse(
                "import org.aspectj.lang.JoinPoint;\n" + 
                "import org.aspectj.lang.annotation.AfterThrowing;\n" + 
                "public aspect Test {\n" + 
                "        @AfterThrowing(pointcut=\"execution(* *(..))\", throwing=\"e\")\n" + 
                "        public void bizLoggerWithException(JoinPoint thisJoinPoint) { }\n" + 
                "}");
    }
    
    // Main type name must be "Test" and must be in default package
    private void assertConvertingParse(String testContentStr) {
        char[] testContent = testContentStr.toCharArray();
        final AspectsConvertingParser convertingParser = new AspectsConvertingParser(testContent);
        convertingParser.content = testContent;
        convertingParser.convert(ConversionOptions.CONSTANT_SIZE);
        
        ICompilationUnit unit = new ICompilationUnit() {
            
            public char[] getFileName() {
                return "Test.java".toCharArray();
            }
            
            public char[][] getPackageName() {
                return new char[0][];
            }
            
            public char[] getMainTypeName() {
                return "Test".toCharArray();
            }
            
            public char[] getContents() {
                return convertingParser.content;
            }
            
            public boolean ignoreOptionalProblems() {
                return false;
            }
        };
        CompilerOptions options = new CompilerOptions();
        options.sourceLevel = ClassFileConstants.JDK1_5;
        options.targetJDK = ClassFileConstants.JDK1_5;
        Parser parser = new Parser(
                new ProblemReporter(DefaultErrorHandlingPolicies
                        .proceedWithAllProblems(), options,
                        new DefaultProblemFactory()), true);
        CompilationResult result = new CompilationResult(unit, 0, 1, 100);
        CompilationUnitDeclaration decl = parser.parse(unit, result);
        if (result.hasErrors()) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < result.getErrors().length; i++) {
                sb.append("\n\t" + result.getErrors()[i].getMessage());
            }
            sb.append("\n============\nOriginal text:\n" + testContentStr);
            sb.append("\n============\nConverted text:\n" + String.valueOf(convertingParser.content));
            fail("Converted unit has errors:" + sb.toString());
        }
    }
}