/*******************************************************************************
 * Copyright (c) 2000, 2014 IBM Corporation 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
 *     Stephan Herrmann - Contribution for
 *								Bug 425183 - [1.8][inference] make CaptureBinding18 safe
 *******************************************************************************/
package org.eclipse.jdt.core.tests.dom;

import java.util.List;

import junit.framework.Test;

import org.eclipse.jdt.core.dom.*;
import org.eclipse.jdt.core.BindingKey;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;

public class ASTConverter18Test extends ConverterTestSetup {

	ICompilationUnit workingCopy;

	public void setUpSuite() throws Exception {
		super.setUpSuite();
		this.ast = AST.newAST(AST.JLS8);
	}

	public ASTConverter18Test(String name) {
		super(name);
	}

	static {
//		TESTS_NUMBERS = new int[] { 19 };
//		TESTS_RANGE = new int[] { 1, -1 };
//		TESTS_NAMES = new String[] {"test0001"};
	}
	public static Test suite() {
		return buildModelTestSuite(ASTConverter18Test.class);
	}

	protected void tearDown() throws Exception {
		super.tearDown();
		if (this.workingCopy != null) {
			this.workingCopy.discardWorkingCopy();
			this.workingCopy = null;
		}
	}

	/*
	 * Type Annotations on Variable Arguments
	 */
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=391898
	public void test0001() throws JavaModelException {
		String contents =
			"    @java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
			"    @interface Marker {\n" +
			"    }\n" +
			"public class X {\n" +
			"	public void foo(int @Marker... args) {\n" +
			"	}\n" +
			" 	public void bar(@Marker int @Marker... args) {\n" +
			" 	}\n" +
			"}";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/);
		ASTNode node = buildAST(
			contents,
			this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 1, 0);
		assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION);
		MethodDeclaration methodDeclaration = (MethodDeclaration) node;
		List parameters = methodDeclaration.parameters();
		assertEquals("wrong size", 1, parameters.size());
		SingleVariableDeclaration parameter = (SingleVariableDeclaration) parameters.get(0);
		List annotations = parameter.varargsAnnotations();
		assertEquals("Wrong number of annotations", 1, annotations.size());
		ASTNode annotation = (ASTNode) annotations.get(0);
		checkSourceRange(annotation, "@Marker", contents);
		node = getASTNode(compilationUnit,1,1);
		assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION);
		parameters = methodDeclaration.parameters();
		assertEquals("Wrong number of parameters", 1, parameters.size());
		parameter = (SingleVariableDeclaration) parameters.get(0);
		annotations = parameter.varargsAnnotations();
		assertEquals("Wrong number of annotations", 1, annotations.size());
		annotation = (ASTNode) annotations.get(0);
		checkSourceRange(annotation, "@Marker", contents);
	}
	/*
	 * Type Annotations on Variable Argument of ArrayType
	 */
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=413569
	public void test413569() throws JavaModelException {
		String contents =
			"import java.lang.annotation.*;\n" +
			"public class X {\n" +
			"	@Target(ElementType.TYPE_USE) static @interface A {}\n" + 
			"	@Target(ElementType.TYPE_USE) static @interface B {}\n" + 
			"	@Target(ElementType.TYPE_USE) static @interface C { Class<?> value() default Object.class; }\n" + 
			"	@Target(ElementType.TYPE_USE) static @interface D { Class<?> d(); }\n" + 
			"	void foo(@A int @B()[] @C(int[].class) [] @D(d=String[].class)... arg) {}\n" +
			"}";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/);
		ASTNode node = buildAST(
			contents,
			this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 0, 4);
		assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION);
		MethodDeclaration methodDeclaration = (MethodDeclaration) node;
		List parameters = methodDeclaration.parameters();
		assertEquals("wrong size", 1, parameters.size());
		SingleVariableDeclaration parameter = (SingleVariableDeclaration) parameters.get(0);
		
		ArrayType type = (ArrayType) parameter.getType();
		List dimensions = type.dimensions();
		assertEquals(2, dimensions.size());
		
		Dimension dimension = (Dimension) dimensions.get(0);
		List annotations = dimension.annotations();
		assertEquals("Wrong number of annotations", 1, annotations.size());
		Annotation annotation = (Annotation) annotations.get(0);
		checkSourceRange(annotation, "@B()", contents);
		
		dimension = (Dimension) dimensions.get(1);
		annotations = dimension.annotations();
		assertEquals("Wrong number of annotations", 1, annotations.size());
		annotation = (Annotation) annotations.get(0);
		checkSourceRange(annotation, "@C(int[].class)", contents);
		
		annotations = parameter.varargsAnnotations();
		assertEquals("Wrong number of annotations", 1, annotations.size());
		annotation = (Annotation) annotations.get(0);
		checkSourceRange(annotation, "@D(d=String[].class)", contents);
		
	}
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=395886 tests annotations on
	 * QTR in multiple scenarios of occurrence.
	 * 
	 * @throws JavaModelException
	 */
	public void test0002() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test0002/X.java",
				true/* resolve */);
		String contents = "package test0002;\n"
				+ "import java.lang.annotation.Target;\n"
				+ "public class X {\n"
				+ "	public static void main(String[] args) {\n"
				+ "		Outer outer = new Outer();\n"
				+ "		Object myObject = new Object();\n"
				+ "		String myString;\n"
				+ "		myString = (java.lang.@Marker String) myObject;\n"
				+ "		Outer.Inner first = outer.new Inner();\n"
				+ "		Outer. @Marker2 Inner second = outer.new Inner() ;\n"
				+ "		Outer.Inner. @Marker1 Deeper deeper = second.new Deeper();\n"
				+ "		Outer.@Marker1 Inner.@Marker2 Deeper deeper2 =  second.new Deeper();\n"
				+ "	}\n" + "}\n" + "class Outer {\n"
				+ "	public class Inner {\n" + "		public class Deeper {\n"
				+ "		}\n" + "	}\n" + "}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker {}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker1 {}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker2 {}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents,
				this.workingCopy);
		MethodDeclaration methodDeclaration = (MethodDeclaration) getASTNode(cu, 0, 0);
		List statements = methodDeclaration.getBody().statements();
		int sCount = 3;

		// case 1 - annotation just before the last field
		ExpressionStatement expressionStatement = (ExpressionStatement) statements.get(sCount++);
		Assignment assignment = (Assignment) expressionStatement.getExpression();
		assertNotNull(assignment);
		CastExpression castExpression = (CastExpression) assignment.getRightHandSide();
		assertNotNull(castExpression);
		NameQualifiedType nameQualifiedType = (NameQualifiedType) castExpression.getType();
		assertNotNull(nameQualifiedType);
		assertEquals("java.lang.@Marker String", nameQualifiedType.toString());
		List annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		assertEquals("@Marker", annotations.get(0).toString());

		// case 2 - QualifiedType without annotations.
		VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) statements.get(sCount++);
		Type type = variableDeclarationStatement.getType();
		assertTrue(type.isSimpleType());
		SimpleType simpleType = (SimpleType) type;
		assertEquals("Outer.Inner", simpleType.toString());
		annotations = simpleType.annotations();
		assertTrue(annotations.size() == 0);

		// case 3 - Qaulified Type with outer without annotations and inner with
		// annotations.
		variableDeclarationStatement = (VariableDeclarationStatement) statements.get(sCount++);
		type = variableDeclarationStatement.getType();
		assertTrue(type.isNameQualifiedType());
		nameQualifiedType = (NameQualifiedType) type;
		assertNotNull(nameQualifiedType);
		assertEquals("Outer.@Marker2 Inner", nameQualifiedType.toString());
		annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		assertEquals("@Marker2", annotations.get(0).toString());

		// case 4 - Multiple levels with annotations at the last only.
		variableDeclarationStatement = (VariableDeclarationStatement) statements.get(sCount++);
		type = variableDeclarationStatement.getType();
		assertTrue(type.isNameQualifiedType());
		nameQualifiedType = (NameQualifiedType) type;
		assertNotNull(nameQualifiedType);
		assertEquals("Outer.Inner.@Marker1 Deeper", nameQualifiedType.toString());
		annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		assertEquals("@Marker1", annotations.get(0).toString());

		// case 5 - Multiple annotations
		variableDeclarationStatement = (VariableDeclarationStatement) statements.get(sCount++);
		type = variableDeclarationStatement.getType();
		assertTrue(type.isQualifiedType());
		QualifiedType qualifiedType = (QualifiedType) type;
		assertNotNull(qualifiedType);
		assertEquals("Outer.@Marker1 Inner.@Marker2 Deeper", qualifiedType.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		assertEquals("@Marker2", annotations.get(0).toString());
		SimpleName simpleName = qualifiedType.getName();
		assertEquals("Deeper", simpleName.toString());
		Type qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isNameQualifiedType());
		nameQualifiedType = (NameQualifiedType) qualifierType;
		assertEquals("Outer.@Marker1 Inner", nameQualifiedType.toString());
		annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		assertEquals("@Marker1", annotations.get(0).toString());
	}

	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=395886 tests the
	 * representation of type annotations on a possible JAVA 7 and 8 place.
	 * 
	 * @throws JavaModelException
	 */
	public void test0003() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test0003/X.java",
				true/* resolve */);
		String contents = "package test0003;\n"
				+ "import java.lang.annotation.Target;\n"
				+ "public class X {\n"
				+ "	public static void main(String[] args) {\n"
				+ "		@Marker Outer.Inner first[] = new Outer.Inner[1];\n"
				+ "	}\n" + "}\n" + "class Outer {\n"
				+ "	public class Inner {\n" + "	}\n" + "}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker {}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		MethodDeclaration methodDeclaration = (MethodDeclaration) getASTNode(cu, 0, 0);
		List statements = methodDeclaration.getBody().statements();
		int sCount = 0;

		// Current design expects annotation only at the JAVA 7 place if it is
		// expected at JAVA 8.
		VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) statements.get(sCount);
		List modifiers = variableDeclarationStatement.modifiers();
		assertTrue(modifiers.size() == 1);
		Annotation annotation = (Annotation) modifiers.get(0);
		assertEquals("@Marker", annotation.toString());
		Type type = variableDeclarationStatement.getType();
		assertTrue(type.isSimpleType());
		SimpleType simpleType = (SimpleType) type;
		assertEquals("Outer.Inner", simpleType.toString());
		List annotations = simpleType.annotations();
		assertTrue(annotations.size() == 0);
	}

	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=395886 tests QTR with
	 * annotations
	 * 
	 * @throws JavaModelException
	 */
	public void test0004() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test0004/X.java",
				true/* resolve */);
		String contents = "package test0004;"
				+ "import java.lang.annotation.Target;\n"
				+ "public class X implements One</*start*/@Marker1 Outer<Integer>. @Marker2 Inner<Double>[]/*end*/> {\n"
				+ "}\n" + "interface One<T> {}\n" + "class Outer<T> {\n"
				+ "	public class Inner<S> {}\n" + "}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker1 {}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker2 {}\n";
		ArrayType type = (ArrayType) buildAST(contents, this.workingCopy);
		assertNotNull("No annotation", type);
		ITypeBinding binding = type.resolveBinding();
		assertNotNull("No binding", binding);
		assertEquals("Wrong qualified name", "test0004.Outer<java.lang.Integer>.Inner<java.lang.Double>[]", binding.getQualifiedName());
		Type elementType = type.getElementType();
		binding = elementType.resolveBinding();
		assertNotNull("No binding", binding);
		assertEquals("Wrong qualified name",
				"test0004.Outer<java.lang.Integer>.Inner<java.lang.Double>", binding.getQualifiedName());
		assertTrue("Not parameterized", elementType.isParameterizedType());
		ParameterizedType parameterizedType = (ParameterizedType) elementType;
		Type type2 = parameterizedType.getType();
		assertTrue("Not qualified", type2.isQualifiedType());
		QualifiedType qualifiedType = (QualifiedType) type2;
		binding = qualifiedType.resolveBinding();
		assertNotNull("No binding", binding);
		assertEquals("Wrong qualified name","test0004.Outer<java.lang.Integer>.Inner<java.lang.Double>", binding.getQualifiedName());
		Type qualifier = qualifiedType.getQualifier();
		assertTrue("Not parameterized", qualifier.isParameterizedType());
		binding = qualifier.resolveBinding();
		assertNotNull("No binding", binding);
		assertEquals("Wrong qualified name", "test0004.Outer<java.lang.Integer>", binding.getQualifiedName());
		parameterizedType = (ParameterizedType) qualifier;
		type2 = parameterizedType.getType();
		assertTrue("Not simple type", type2.isSimpleType());
		binding = type2.resolveBinding();
		assertNotNull("No binding", binding);
		assertEquals("Wrong qualified name","test0004.Outer<java.lang.Integer>", binding.getQualifiedName());
	}

	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=395886 tests QTR with
	 * annotations
	 * 
	 * @throws JavaModelException
	 */
	public void test0005() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test0005/X.java",
				true/* resolve */);
		String contents = "package test0005;"
				+ "import java.lang.annotation.Target;\n"
				+ "public class X implements One< Outer.Inner > {\n"
				+ "}\n"
				+ "class Y implements One< Outer. @Marker1 Inner > {\n"
				+ "}\n"
				+ "class Z implements One< @Marker1 Outer.Inner > {\n"
				+ "}\n"
				+ "class W implements One< @Marker1 Outer. @Marker2 Inner > {\n"
				+ "}\n" + "interface One<T> {}\n" + "class Outer {\n"
				+ "	public class Inner {}\n" + "}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker1 {}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker2 {}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents,
				this.workingCopy);
		int tCount = 0;

		// case 1 - no annotations Outer.Inner
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		ParameterizedType parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		List typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		Type type = (Type) typeArguments.get(0);
		assertTrue(type.isSimpleType());
		assertEquals("Outer.Inner", type.toString());

		// case 2 - QTR with one annotation Outer.@Marker1 Inner
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration
				.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		type = (Type) typeArguments.get(0);
		assertTrue(type.isNameQualifiedType());
		NameQualifiedType nameQualifiedType = (NameQualifiedType) type;
		assertEquals("Outer.@Marker1 Inner", nameQualifiedType.toString());
		List annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		Annotation annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());

		// case 3 - QTR with one annotation at the beginning @Marker1
		// Outer.Inner
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		type = (Type) typeArguments.get(0);
		assertTrue(type.isQualifiedType());
		assertEquals("@Marker1 Outer.Inner", type.toString());
		QualifiedType qualifiedType = (QualifiedType) type;
		assertEquals("Inner", qualifiedType.getName().toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 0);
		Type qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isSimpleType());
		SimpleType simpleType = (SimpleType) qualifierType;
		assertEquals("@Marker1 Outer", simpleType.toString());
		annotations = simpleType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());

		// case 4 - QTR with annotations at both the types @Marker1
		// Outer.@Marker2 Inner
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		type = (Type) typeArguments.get(0);
		assertTrue(type.isQualifiedType());
		assertEquals("@Marker1 Outer.@Marker2 Inner", type.toString());
		qualifiedType = (QualifiedType) type;
		assertEquals("Inner", qualifiedType.getName().toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker2", annotation.toString());
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isSimpleType());
		simpleType = (SimpleType) qualifierType;
		assertEquals("@Marker1 Outer", simpleType.toString());
		annotations = simpleType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());

	}

	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=395886 tests PQTR with
	 * annotations part
	 * 
	 * @throws JavaModelException
	 */
	public void test0006() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test0006/X.java",
				true);
		String contents = "package test0006;"
				+ "import java.lang.annotation.Target;\n"
				+ "public class X implements One<Outer.  Inner.Deeper<Double>> {\n"
				+ "}\n"
				+ "class X1 implements One<Outer. @Marker1 Inner.Deeper<Double>> {\n"
				+ "}\n"
				+ "class X2 implements One<Outer. @Marker1 Inner.@Marker2 Deeper<Double>> {\n"
				+ "}\n"
				+ "class X3 implements One<@Marker1 Outer. @Marker2 Inner. Deeper<Double>> {\n"
				+ "}\n"
				+ "class Y implements One<Outer1. Inner<Integer>. Deeper<Double>> {\n"
				+ "}\n"
				+ "class Y1 implements One<Outer1. Inner<Integer>. @Marker1 Deeper<Double>> {\n"
				+ "}\n"
				+ "class Y2 implements One<Outer1. @Marker1 Inner<Integer>. Deeper<Double>> {\n"
				+ "}\n"
				+ "class Y3 implements One<@Marker1 Outer1. Inner<Integer>. Deeper<Double>> {\n"
				+ "}\n"
				+ "class Y4 implements One<@Marker1 Outer1. @Marker2 Inner<Integer>. Deeper<Double>> {\n"
				+ "}\n"
				+ "class Z implements One<Outer2<Integer>.Inner.Deeper<Double>> {\n"
				+ "}\n"
				+ "class Z1 implements One<@Marker1 Outer2<Integer>.Inner.Deeper<Double>> {\n"
				+ "}\n"
				+ "class Z2 implements One<Outer2<Integer>. @Marker1 Inner.@Marker2 Deeper<Double>> {\n"
				+ "}\n"
				+ "class W implements One<Outer3<Double>. @Marker1 @Marker2 Inner<Integer, Character>. Deeper<Double>> {\n"
				+ "}\n" + "interface One<T> {}\n" + "class Outer {\n"
				+ "	public class Inner {\n"
				+ "       public class Deeper<S> {\n" + "       }\n" + "   }\n"
				+ "}\n" + "class Outer1 {\n" + "	public class Inner<T> {\n"
				+ "       public class Deeper<S> {\n" + "       }\n" + "   }\n"
				+ "}\n" + "class Outer2 <T> {\n" + "	public class Inner {\n"
				+ "       public class Deeper<S> {}\n" + "   }\n" + "}\n"
				+ "class Outer3 <T> {\n" + "	public class Inner<K, V> {\n"
				+ "       public class Deeper<S> {}\n" + "   }\n" + "}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker1 {}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker2 {}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents,
				this.workingCopy);
		int tCount = 0;

		// case 1: vanilla case without annotations and with single typeArgument
		// Outer.Inner.Deeper<Double>
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		ParameterizedType parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		List typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("Outer.Inner.Deeper<Double>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		Type type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isSimpleType());
		SimpleType simpleType = (SimpleType) type;
		assertEquals("Outer.Inner.Deeper", simpleType.toString());
		Name name = simpleType.getName();
		assertTrue(name.isQualifiedName());
		QualifiedName qualifiedName = (QualifiedName) name;
		assertEquals("Outer.Inner.Deeper", qualifiedName.toString());

		// case 2 - One annotation after the first class
		// Outer. @Marker1 Inner.Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("Outer.@Marker1 Inner.Deeper<Double>",	parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		QualifiedType qualifiedType = (QualifiedType) type;
		assertEquals("Outer.@Marker1 Inner.Deeper", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		List annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 0);
		NameQualifiedType nameQualifiedType = (NameQualifiedType) qualifiedType.getQualifier();
		assertEquals("Outer.@Marker1 Inner", nameQualifiedType.toString());
		annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		Annotation annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());

		// case 3 - Inner types annotated with outer not annotated with last
		// type arg
		// Outer. @Marker1 Inner.@Marker2 Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("Outer.@Marker1 Inner.@Marker2 Deeper<Double>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("Outer.@Marker1 Inner.@Marker2 Deeper", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker2", annotation.toString());
		Type qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isNameQualifiedType());
		nameQualifiedType = (NameQualifiedType) qualifierType;
		assertEquals("Outer.@Marker1 Inner", nameQualifiedType.toString());
		annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());

		// case 4 - one annotation on the outermost, one in middle and one
		// typearg in innermost
		// @Marker1 Outer. @Marker2 Inner. Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration
				.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("@Marker1 Outer.@Marker2 Inner.Deeper<Double>", parametrizedType.toString());
		ITypeBinding typeBinding = parametrizedType.resolveBinding();
		assertNotNull("Binding non-null", typeBinding);
		assertEquals("wrong qualified name", "test0006.Outer.Inner.Deeper<java.lang.Double>", typeBinding.getQualifiedName());
		assertTrue("Not a Parameterized Type", typeBinding.isParameterizedType());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("@Marker1 Outer.@Marker2 Inner.Deeper", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		annotations = qualifiedType.annotations();
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isQualifiedType());
		qualifiedType = (QualifiedType) qualifierType;
		assertEquals("@Marker1 Outer.@Marker2 Inner", qualifierType.toString());
		typeBinding = qualifiedType.resolveBinding();
		assertNotNull("Binding non-null", typeBinding);
		typeBinding = qualifiedType.resolveBinding();
		assertEquals("wrong qualified name", "test0006.Outer.Inner", typeBinding.getQualifiedName());
		assertTrue(qualifierType.isAnnotatable());
		AnnotatableType annotatableType = (AnnotatableType) qualifierType;
		annotations = annotatableType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker2", annotation.toString());
		name = qualifiedType.getName();
		assertEquals("Inner", name.toString());
		type = qualifiedType.getQualifier();
		assertTrue(type.isSimpleType());
		simpleType = (SimpleType) type;
		assertEquals("@Marker1 Outer", simpleType.toString());
		annotations = simpleType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());

		// case 5 - without annotations, but with typeargs at second and third
		// types
		// Outer1. Inner<Integer>. Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("Outer1.Inner<Integer>.Deeper<Double>",parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("Outer1.Inner<Integer>.Deeper", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 0);
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isParameterizedType());
		parametrizedType = (ParameterizedType) qualifierType;
		assertEquals("Outer1.Inner<Integer>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Integer", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isSimpleType());
		simpleType = (SimpleType) type;
		name = simpleType.getName();
		assertTrue(name.isQualifiedName());
		qualifiedName = (QualifiedName) name;
		assertEquals("Outer1.Inner", qualifiedName.toString());

		// case 6 - Annot in between two PQRT with outermost neither annotated
		// nor having typeargs
		// Outer1. Inner<Integer>. @Marker1 Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("Outer1.Inner<Integer>.@Marker1 Deeper<Double>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("Outer1.Inner<Integer>.@Marker1 Deeper", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isParameterizedType());
		parametrizedType = (ParameterizedType) qualifierType;
		assertEquals("Outer1.Inner<Integer>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Integer", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isSimpleType());
		simpleType = (SimpleType) type;
		name = simpleType.getName();
		assertTrue(name.isQualifiedName());
		qualifiedName = (QualifiedName) name;
		assertEquals("Outer1.Inner", qualifiedName.toString());

		// case 7 - Outermost still empty (no annotations, no type args),
		// followed by annotation, and then typeargs
		// Outer1. @Marker1 Inner<Integer>. Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("Outer1.@Marker1 Inner<Integer>.Deeper<Double>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("Outer1.@Marker1 Inner<Integer>.Deeper", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 0);
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isParameterizedType());
		parametrizedType = (ParameterizedType) qualifierType;
		assertEquals("Outer1.@Marker1 Inner<Integer>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Integer", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isNameQualifiedType());
		nameQualifiedType = (NameQualifiedType) type;
		assertEquals("Outer1.@Marker1 Inner", nameQualifiedType.toString());
		annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());

		// case 8 - Similar to above, but with the major difference of
		// annotation shifted to outermost.
		// @Marker1 Outer1. Inner<Integer>. Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("@Marker1 Outer1.Inner<Integer>.Deeper<Double>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("@Marker1 Outer1.Inner<Integer>.Deeper", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 0);
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isParameterizedType());
		parametrizedType = (ParameterizedType) qualifierType;
		assertEquals("@Marker1 Outer1.Inner<Integer>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Integer", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("@Marker1 Outer1.Inner", qualifiedType.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 0);
		name = qualifiedType.getName();
		assertTrue(name.isSimpleName());
		assertEquals("Inner", name.toString());
		type = qualifiedType.getQualifier();
		assertTrue(type.isSimpleType());
		simpleType = (SimpleType) type;
		annotations = simpleType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());
		name = simpleType.getName();
		assertTrue(name.isSimpleName());
		assertEquals("Outer1", name.toString());

		// case 9: scenario of the above case plus another annotation at
		// mid-level.
		// @Marker1 Outer1.@Marker2 Inner<Integer>. Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("@Marker1 Outer1.@Marker2 Inner<Integer>.Deeper<Double>",parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("@Marker1 Outer1.@Marker2 Inner<Integer>.Deeper", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 0);
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isParameterizedType());
		parametrizedType = (ParameterizedType) qualifierType;
		assertEquals("@Marker1 Outer1.@Marker2 Inner<Integer>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Integer", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("@Marker1 Outer1.@Marker2 Inner", qualifiedType.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker2", annotation.toString());
		name = qualifiedType.getName();
		assertTrue(name.isSimpleName());
		assertEquals("Inner", name.toString());
		type = qualifiedType.getQualifier();
		assertTrue(type.isSimpleType());
		simpleType = (SimpleType) type;
		annotations = simpleType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());
		name = simpleType.getName();
		assertTrue(name.isSimpleName());
		assertEquals("Outer1", name.toString());

		// case 10 - PQRT with two type args but without annotations
		// Outer2<Integer>.Inner.Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("Outer2<Integer>.Inner.Deeper<Double>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("Outer2<Integer>.Inner.Deeper", qualifiedType.toString());
		ITypeBinding binding = qualifiedType.resolveBinding();
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 0);
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isQualifiedType());
		qualifiedType = (QualifiedType) qualifierType;
		binding = qualifiedType.resolveBinding();
		assertEquals("Outer2<Integer>.Inner", qualifiedType.toString());
		assertEquals("wrong qualified binding", "test0006.Outer2<java.lang.Integer>.Inner",	binding.getQualifiedName());
		name = qualifiedType.getName();
		assertEquals("Inner", name.toString());
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isParameterizedType());
		parametrizedType = (ParameterizedType) qualifierType;
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Integer", type.toString());
		type = parametrizedType.getType();
		assertEquals("Outer2", type.toString());

		// case 11 - annotation at outermost in addition to scenario in case 10.
		// @Marker1 Outer2<Integer>.Inner.Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("@Marker1 Outer2<Integer>.Inner.Deeper<Double>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("@Marker1 Outer2<Integer>.Inner.Deeper", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 0);
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isQualifiedType());
		qualifiedType = (QualifiedType) qualifierType;
		assertEquals("@Marker1 Outer2<Integer>.Inner", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Inner", name.toString());
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isParameterizedType());
		parametrizedType = (ParameterizedType) qualifierType;
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Integer", type.toString());
		type = parametrizedType.getType();
		assertEquals("@Marker1 Outer2", type.toString());
		assertTrue(type.isSimpleType());
		simpleType = (SimpleType) type;
		annotations = simpleType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());

		// case 12 - No annotations at outermost, but outermost has
		// typeAnnotations.
		// Outer2<Integer>. @Marker1 Inner.@Marker2 Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("Outer2<Integer>.@Marker1 Inner.@Marker2 Deeper<Double>", parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("Outer2<Integer>.@Marker1 Inner.@Marker2 Deeper",qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker2", annotation.toString());
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isQualifiedType());
		qualifiedType = (QualifiedType) qualifierType;
		assertEquals("Outer2<Integer>.@Marker1 Inner", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Inner", name.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		assertEquals("@Marker1", annotation.toString());
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isParameterizedType());
		parametrizedType = (ParameterizedType) qualifierType;
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Integer", type.toString());
		type = parametrizedType.getType();
		assertEquals("Outer2", type.toString());
		assertTrue(type.isSimpleType());

		// case 13 - a list of annotations and multiple typeArgument element
		// lists.
		// Outer3<Double>. @Marker1 @Marker2 Inner<Integer, Character>.
		// Deeper<Double>
		typedeclaration = (TypeDeclaration) getASTNode(cu, tCount++);
		parametrizedType = (ParameterizedType) typedeclaration.superInterfaceTypes().get(0);
		typeArguments = parametrizedType.typeArguments();
		assertEquals(1, typeArguments.size());
		parametrizedType = (ParameterizedType) typeArguments.get(0);
		assertEquals("Outer3<Double>.@Marker1 @Marker2 Inner<Integer,Character>.Deeper<Double>",parametrizedType.toString());
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertEquals("Double", type.toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("Outer3<Double>.@Marker1 @Marker2 Inner<Integer,Character>.Deeper", qualifiedType.toString());
		name = qualifiedType.getName();
		assertEquals("Deeper", name.toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 0);
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isParameterizedType());
		parametrizedType = (ParameterizedType) qualifierType;
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 2);
		assertEquals("Integer", typeArguments.get(0).toString());
		assertEquals("Character", typeArguments.get(1).toString());
		type = parametrizedType.getType();
		assertTrue(type.isQualifiedType());
		qualifiedType = (QualifiedType) type;
		assertEquals("Inner", qualifiedType.getName().toString());
		annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 2);
		assertEquals("@Marker1", annotations.get(0).toString());
		assertEquals("@Marker2", annotations.get(1).toString());
		qualifierType = qualifiedType.getQualifier();
		assertTrue(qualifierType.isParameterizedType());
		parametrizedType = (ParameterizedType) qualifierType;
		typeArguments = parametrizedType.typeArguments();
		assertTrue(typeArguments.size() == 1);
		assertEquals("Double", typeArguments.get(0).toString());
		type = parametrizedType.getType();
		assertTrue(type.isSimpleType());
		simpleType = (SimpleType) type;
		assertEquals("Outer3", simpleType.toString());
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=391893
	public void test0007() throws JavaModelException {
		String contents =
			"public class X {\n" +
			"	public void foo(@Marker @Marker2 X this, @Marker2 @Marker int i){}\n" +
			"}\n" +
			"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
			"@interface Marker {}\n" +
			"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
			"@interface Marker2 {}";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		node = getASTNode(unit, 0, 0);
		assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		MethodDeclaration method = (MethodDeclaration) node;
		Type receiver = method.getReceiverType();
		assertEquals("Not a simple type", ASTNode.SIMPLE_TYPE, receiver.getNodeType());
		assertEquals("Incorrect receiver signature", "@Marker @Marker2 X", ((SimpleType) receiver).toString());
		assertEquals("Incorrect annotations on receiver", 2, ((SimpleType) receiver).annotations().size());
		assertNull("Incorrect receiver qualfier", method.getReceiverQualifier());
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=391893
	public void test0008() throws JavaModelException {
		String contents =
			"public class X {\n" +
			"	class Y {\n" +
			"		public Y(@Marker @Marker2 X X.this, @Marker2 @Marker int i){}\n" +
			"	}\n" +
			"}\n" +
			"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
			"@interface Marker {}\n" +
			"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
			"@interface Marker2 {}";

		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		node = getASTNode(unit, 0, 0);
		assertEquals("Not a type Declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		TypeDeclaration innerType = (TypeDeclaration) node;
		assertEquals("Incorrect no of methods", 1, innerType.getMethods().length);
		MethodDeclaration method = innerType.getMethods()[0];
		Type receiver = method.getReceiverType();
		assertEquals("Not a simple type", ASTNode.SIMPLE_TYPE, receiver.getNodeType());
		assertEquals("Incorrect receiver signature", "@Marker @Marker2 X", ((SimpleType) receiver).toString());
		assertEquals("Incorrect annotations on receiver", 2, ((SimpleType) receiver).annotations().size());
		assertNotNull("Incorrect receiver qualfier", method.getReceiverQualifier());
		assertEquals("Incorrect receiver qualfier", "X", method.getReceiverQualifier().getFullyQualifiedName());
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=391895
	public void test0009() throws JavaModelException {
		String contents =
				"import java.lang.annotation.ElementType;\n" +
						"public class X {\n" +
						" 	class Y {\n" +
						"		@Annot int @Annot1 [] a @Annot2 @Annot3 [] @Annot3 @Annot2 [] @Annot4 [], b @Annot2 @Annot3 [] @Annot4 [], c [][][];\n" +  
						"		public void foo1(@Annot int @Annot1 [] p @Annot2 @Annot3 [] @Annot3 @Annot2 [] @Annot4 @Annot3 []) {}\n" +
						"		public void foo2(@Annot int p [][]) {}\n" +
						"		@Annot String @Annot1 [] foo3() @Annot1 @Annot2 [][] { return null; }\n" + 
						"	}\n" +
						"}\n" +
						"@java.lang.annotation.Target(value = {ElementType.TYPE_USE})\n" + 
						"@interface Annot {}\n" +
						"@java.lang.annotation.Target(value = {ElementType.TYPE_USE})\n" + 
						"@interface Annot1 {}\n" +
						"@java.lang.annotation.Target(value = {ElementType.TYPE_USE})\n" +
						"@interface Annot2 {}\n" +
						"@java.lang.annotation.Target(value = {ElementType.TYPE_USE})\n" + 
						"@interface Annot3 {}\n" +
						"@java.lang.annotation.Target(value = {ElementType.TYPE_USE})\n" +
						"@interface Annot4 {}";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		node = getASTNode(unit, 0, 0);
		assertEquals("Not a type Declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		TypeDeclaration type = (TypeDeclaration) node;
		FieldDeclaration field = type.getFields()[0];
		List fragments = field.fragments();
		assertEquals("Incorrect no of fragments", 3, fragments.size());
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0);
		assertExtraDimensionsEqual("Incorrect extra dimensions", fragment.extraDimensions(), "@Annot2 @Annot3 [] @Annot3 @Annot2 [] @Annot4 []");
		fragment = (VariableDeclarationFragment) fragments.get(1);
		assertExtraDimensionsEqual("Incorrect extra dimensions", fragment.extraDimensions(), "@Annot2 @Annot3 [] @Annot4 []");		
		fragment = (VariableDeclarationFragment) fragments.get(2);
		assertExtraDimensionsEqual("Incorrect extra dimensions", fragment.extraDimensions(), "[] [] []");
		MethodDeclaration[] methods = type.getMethods();
		assertEquals("Incorrect no of methods", 3, methods.length);
		MethodDeclaration method = methods[0];
		List parameters = method.parameters();
		assertEquals("Incorrect no of parameters", 1, parameters.size());
		assertExtraDimensionsEqual("Incorrect extra dimensions", ((SingleVariableDeclaration) parameters.get(0)).extraDimensions(), "@Annot2 @Annot3 [] @Annot3 @Annot2 [] @Annot4 @Annot3 []");

		method = methods[1];
		parameters = method.parameters();
		assertEquals("Incorrect no of parameters", 1, parameters.size());
		assertExtraDimensionsEqual("Incorrect extra dimensions", ((SingleVariableDeclaration) parameters.get(0)).extraDimensions(), "[] []");

		method = methods[2];
		assertExtraDimensionsEqual("Incorrect extra dimensions", method.extraDimensions(), "@Annot1 @Annot2 [] []");
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=399600
	public void test0010() throws JavaModelException {
		String contents =
				"import java.lang.annotation.ElementType;\n" +
						"public class X {\n" +
						"	@Marker int foo(@Marker(\"Blah\") int z) @Marker [] @Marker [] {\n" +
						"		return null;\n" +
						"	}\n" +
						"}\n" +
						"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" +
						"@interface Marker {\n" +
						"	String value() default \"Blah\";\n" +
						"}";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		node = getASTNode(unit, 0, 0);
		assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		MethodDeclaration method = (MethodDeclaration) node;
		assertExtraDimensionsEqual("Incorrect extra dimensions", method.extraDimensions(), "@Marker [] @Marker []");
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=391894
	public void test0011() throws JavaModelException {
		String contents =
				"import java.lang.annotation.ElementType;\n" +
				"public class X {\n" +
				" 	public void foo() {\n" +
				"		int @Marker [][][] i = new @Marker2 int @Marker @Marker2 [2] @Marker2 @Marker3 [bar()] @Marker3 @Marker []; \n" +  
				"		int @Marker [][][] j = new @Marker int @Marker3 @Marker [2] @Marker @Marker2 [X.bar2(2)] @Marker2 @Marker3 [];\n" +
				"	}\n" +
				"	public int bar() {\n" +
				"		return 2;\n" +
				"	}\n" +
				"	public static int bar2(int k) {\n" +
				"		return k;\n" +
				"	}\n" +
				"}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + 
				"@interface Marker {}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + 
				"@interface Marker2 {}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + 
				"@interface Marker3 {}";
		
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		node = getASTNode(unit, 0, 0);
		assertEquals("Not a Method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		MethodDeclaration method = (MethodDeclaration) node;
		List list = method.getBody().statements();
		assertEquals("Incorrect no of statements", 2, list.size());
		VariableDeclarationStatement statement1 = (VariableDeclarationStatement) list.get(0);
		VariableDeclarationStatement statement2 = (VariableDeclarationStatement) list.get(1);
		list = statement1.fragments();
		assertEquals("Incorrect no of fragments", 1, list.size());
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) list.get(0);
		ArrayCreation creation = (ArrayCreation) fragment.getInitializer();
		Type type = creation.getType();
		assertEquals("Incorrect type", true, type.isArrayType());
		checkSourceRange(type, "@Marker2 int @Marker @Marker2 [2] @Marker2 @Marker3 [bar()] @Marker3 @Marker []", contents.toCharArray());
		Dimension dimension = (Dimension) ((ArrayType) type).dimensions().get(2);
		assertEquals("Incorrect annotations", "@Marker3 @Marker ", convertAnnotationsList(dimension.annotations()));
		dimension = (Dimension) ((ArrayType) type).dimensions().get(1);
		assertEquals("Incorrect annotations", "@Marker2 @Marker3 ", convertAnnotationsList(dimension.annotations()));
		dimension = (Dimension) ((ArrayType) type).dimensions().get(0);
		assertEquals("Incorrect annotations", "@Marker @Marker2 ", convertAnnotationsList(dimension.annotations()));
		List dimensions = creation.dimensions();
		assertEquals("Incorrect expressions", 2, dimensions.size());
		assertEquals("Incorrect expressions", "2", dimensions.get(0).toString());
		assertEquals("Incorrect expressions", "bar()", dimensions.get(1).toString());
		
		list = statement2.fragments();
		assertEquals("Incorrect no of fragments", 1, list.size());
		fragment = (VariableDeclarationFragment) list.get(0);
		creation = (ArrayCreation) fragment.getInitializer();
		checkSourceRange(creation.getType(), "@Marker int @Marker3 @Marker [2] @Marker @Marker2 [X.bar2(2)] @Marker2 @Marker3 []", contents.toCharArray());
		
		type = creation.getType();
		assertEquals("Incorrect type", true, type.isArrayType());
		dimension = (Dimension) ((ArrayType) type).dimensions().get(2);
		assertEquals("Incorrect annotations", "@Marker2 @Marker3 ", convertAnnotationsList(dimension.annotations()));
		dimension = (Dimension) ((ArrayType) type).dimensions().get(1);
		assertEquals("Incorrect annotations", "@Marker @Marker2 ", convertAnnotationsList(dimension.annotations()));
		dimension = (Dimension) ((ArrayType) type).dimensions().get(0);
		assertEquals("Incorrect annotations", "@Marker3 @Marker ", convertAnnotationsList(dimension.annotations()));
		dimensions = creation.dimensions();
		assertEquals("Incorrect expressions", 2, dimensions.size());
		assertEquals("Incorrect expressions", "2", dimensions.get(0).toString());
		assertEquals("Incorrect expressions", "X.bar2(2)", dimensions.get(1).toString());
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=391894
	public void test0012() throws JavaModelException {
		String contents =
				"import java.lang.annotation.ElementType;\n" +
				"public class X {\n" +
				" 	public void foo() {\n" +
				"		int @Marker [][][] i = new @Marker2 int @Marker @Marker2 [] @Marker2 @Marker3 [] @Marker3 @Marker [] {{{1, 2, 3}}}; \n" +  
				"	}\n" +
				"}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + 
				"@interface Marker {}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + 
				"@interface Marker2 {}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + 
				"@interface Marker3 {}";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		node = getASTNode(unit, 0, 0);
		assertEquals("Not a Method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		MethodDeclaration method = (MethodDeclaration) node;
		List list = method.getBody().statements();
		assertEquals("Incorrect no of statements", 1, list.size());
		VariableDeclarationStatement statement1 = (VariableDeclarationStatement) list.get(0);
		list = statement1.fragments();
		assertEquals("Incorrect no of fragments", 1, list.size());
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) list.get(0);
		ArrayCreation creation = (ArrayCreation) fragment.getInitializer();
		Type type = creation.getType();
		assertEquals("Incorrect type", true, type.isArrayType());
		checkSourceRange(type, "@Marker2 int @Marker @Marker2 [] @Marker2 @Marker3 [] @Marker3 @Marker []", contents.toCharArray());
		ArrayInitializer initializer = creation.getInitializer();
		checkSourceRange(initializer, "{{{1, 2, 3}}}", contents.toCharArray());
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=391894
	// Force to use JLS4 and confirm malformed flags are set.
	public void test0021() throws JavaModelException {
		String contents =
				"import java.lang.annotation.ElementType;\n" +
				"public class X {\n" +
				" 	public void foo() {\n" +
				"		int @Marker [][][] i = new @Marker2 int @Marker @Marker2 [] @Marker2 @Marker3 [] @Marker3 @Marker [] {{{1, 2, 3}}}; \n" +  
				"	}\n" +
				"}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + 
				"@interface Marker {}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + 
				"@interface Marker2 {}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" + 
				"@interface Marker3 {}";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		CompilationUnit unit = (CompilationUnit) buildAST(getJLS4(), contents, this.workingCopy, true, true, true);
		
		ASTNode node = getASTNode(unit, 0, 0);
		assertEquals("Not a Method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		MethodDeclaration method = (MethodDeclaration) node;
		List list = method.getBody().statements();
		assertEquals("Incorrect no of statements", 1, list.size());
		VariableDeclarationStatement statement1 = (VariableDeclarationStatement) list.get(0);
		list = statement1.fragments();
		assertEquals("Incorrect no of fragments", 1, list.size());
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) list.get(0);
		ArrayCreation creation = (ArrayCreation) fragment.getInitializer();
		Type type = creation.getType();
		assertEquals("Incorrect type", true, type.isArrayType());
		assertEquals("Type should be malformed", ASTNode.MALFORMED, (type.getFlags() & ASTNode.MALFORMED));
	}
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399768
	 * 
	 * @throws JavaModelException
	 */
	public void test0013() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test0010/X.java",
				true/* resolve */);
		String contents = "package test0010;"
				+ "import java.lang.annotation.Target;\n"
				+ "public class X implements One<@Marker1 Integer, @Marker2 Boolean> {\n"
				+ "}\n" 		
				+ "class Y implements One<@Marker1 @Marker2 Integer, @Marker2 @Marker1 Double> {\n"
				+ "}\n" 		
				+ "interface One<T, U> {}\n" 
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker1 {}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker2 {}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		// simple types for generic type arguments to parameterized classes
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0);
		Type type = (Type)((ParameterizedType) typedeclaration.superInterfaceTypes().get(0)).typeArguments().get(0);
		assertTrue(type.isSimpleType());
		SimpleType simpleType = (SimpleType) type;
		List annotations = simpleType.annotations();
		assertEquals("wrong number of annotations", 1, annotations.size());
		assertEquals("@Marker1", annotations.get(0).toString());
		assertNotNull("No annotation", type);
		typedeclaration = (TypeDeclaration) getASTNode(cu, 1);
		type = (Type)((ParameterizedType) typedeclaration.superInterfaceTypes().get(0)).typeArguments().get(0);
		assertTrue(type.isSimpleType());
		simpleType = (SimpleType) type;
		annotations = simpleType.annotations();
		assertEquals("wrong number of annotations", 2, annotations.size());
		assertEquals("@Marker2", annotations.get(1).toString());
		assertNotNull("No annotation", type);	
		type = (Type)((ParameterizedType) typedeclaration.superInterfaceTypes().get(0)).typeArguments().get(1);
		assertTrue(type.isSimpleType());
		simpleType = (SimpleType) type;
		annotations = simpleType.annotations();
		assertEquals("wrong number of annotations", 2, annotations.size());
		assertEquals("@Marker1", annotations.get(1).toString());
		assertNotNull("No annotation", type);	
	}
	
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399768
	 * 
	 * @throws JavaModelException
	 */
	public void test0014() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test0011/X.java",
				true/* resolve */);
		String contents = "package test0011;"
				+ "import java.lang.annotation.Target;\n"
				+ "public class X {\n"
				+ "	public void foo() {\n"
				+ " 	Y y = new <@Marker2 @Marker1 String> Y(new String(\"Hello\"));\n"
				+ " 	len = y.<@Marker1 @Marker2 String> bar(new String(\"World\"));\n"
				+ " }\n"
				+ "	public int len;\n"
				+ "}\n" 		
				+ "class Y {\n"
				+ "	public <T> Y(T t) {\n"
				+ "		len = t instanceof String ? ((String)t).length() : 0;\n"
				+ "	}\n"
				+ "	public <T> int bar(T t) {\n"
				+ "		return t instanceof String ? ((String)t).length() : len;\n"
				+ "	}\n"
				+ " private int len;\n"
				+ "}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker1 {}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker2 {}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		// simple type for generic type arguments in a generic method or constructor invocation
		MethodDeclaration methodDeclaration = (MethodDeclaration) getASTNode(cu, 0, 0);
		List statements = methodDeclaration.getBody().statements();
		Statement statement = (Statement)statements.get(0);
		VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement) statement;
		VariableDeclarationFragment variableDeclarationFragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
		Expression expression = variableDeclarationFragment.getInitializer();
		ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) expression;
		Type type = (Type) classInstanceCreation.typeArguments().get(0);
		assertEquals("@Marker2 @Marker1 String", type.toString());
		assertTrue(type.isSimpleType());
		SimpleType simpleType = (SimpleType) type;
		List annotations = simpleType.annotations();
		assertEquals("wrong number of annotations", 2, annotations.size());
		assertEquals("@Marker2", annotations.get(0).toString());
		statement = (Statement) statements.get(1);
		Assignment assignment  = (Assignment) ((ExpressionStatement)statement).getExpression();
		expression = assignment.getRightHandSide();
		MethodInvocation methodInvocation = (MethodInvocation) expression;
		simpleType = (SimpleType)methodInvocation.typeArguments().get(0);
		annotations = simpleType.annotations();
		assertEquals("wrong number of annotations", 2, annotations.size());
		assertEquals("@Marker1", annotations.get(0).toString());
	}

	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399768
	 * 
	 * @throws JavaModelException
	 */
	public void test0015() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test0012/X.java",
				true/* resolve */);
		String contents = "package test0012;"
				+ "import java.lang.annotation.Target;\n"
				+ "import java.io.File;\n"
				+ "public class X <@Marker1 @Marker3 F extends @Marker1 @Marker2 File> {\n"
				+ "	public int foo(F f) {\n"
				+ " 	Y <@Marker2 @Marker3 ? super @Marker1 @Marker2 File> y = new @Marker2 @Marker1 Y<File>();\n"
				+ "		Outer o = new @Marker1 @Marker2 Outer();\n"	
				+ "		Outer.Inner inner = o.new @Marker1 @Marker2 Inner();\n"	
				+  " 	ZZ zz = new <String> @Marker1 @Marker2 ZZ();\n" 
				+ " 	return f.getName().length() + y.hashCode() + inner.hashCode();\n"
				+ " }\n"
				+ "}\n" 		
				+ "class Y<@Marker3 T> {\n"
				+ "	public int bar(T t) {\n"
				+ "		return t instanceof @Marker1 @Marker2 File ? t.toString().length() : 0;\n"
				+ "	}\n"
				+ "}\n"
				+ "class Outer {\n"
				+ "	public class Inner {\n" 
				+ "		public class Deeper {\n"
				+ "		}\n" 
				+ "	}\n"
				+ "}\n"
				+ "class ZZ {\n"
				+ "public @Marker1 @Marker2 <T> ZZ() {\n"
				+ "	T t = null;\n"
				+ "	len =  t instanceof String ? t.hashCode() : 0;\n"
				+ "}\n"
				+ "public @Marker1 int  getint(@Marker2 @Marker1 ZZ this) {return len;}\n"
				+ "public int len;\n"
				+ "}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker1 {}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker2 {}\n"
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker3 {}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0);
		TypeParameter typeParameter = (TypeParameter) typedeclaration.typeParameters().get(0);

		// TypeParameter with TYPE_USE and TYPE_PARAMETER annotation combination.
		assertEquals("@Marker1 @Marker3 F extends @Marker1 @Marker2 File", typeParameter.toString());
		assertTrue(typeParameter.modifiers().size() == 2);
		Annotation annotation = (Annotation)typeParameter.modifiers().get(1);
		assertEquals("@Marker3", annotation.toString());
		IAnnotationBinding abinding = annotation.resolveAnnotationBinding();
		assertEquals("@Marker3()", abinding.toString());

		// simpletype for type parameter bounds
		SimpleType simpleType = (SimpleType) typeParameter.typeBounds().get(0);
		annotation = (Annotation) simpleType.annotations().get(1);
		assertEquals("@Marker2", annotation.toString());
		abinding = annotation.resolveAnnotationBinding();
		assertEquals("@Marker2()", abinding.toString());

		MethodDeclaration methodDeclaration = (MethodDeclaration) getASTNode(cu, 0, 0);
		List statements = methodDeclaration.getBody().statements();
		Statement statement = (Statement)statements.get(0);
		VariableDeclarationStatement variableDeclarationStatement = (VariableDeclarationStatement)statement;
		Type type = variableDeclarationStatement.getType();
		assertTrue(type.isParameterizedType());
		type = (Type)((ParameterizedType)type).typeArguments().get(0);
		assertTrue(type.isWildcardType());
		
		// for constructor invocation results 1/4
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
		Expression expression = fragment.getInitializer();
		assertEquals("new @Marker2 @Marker1 Y<File>()", expression.toString());
		simpleType = (SimpleType) ((ParameterizedType)((ClassInstanceCreation)expression).getType()).getType();
		assertEquals("@Marker2 @Marker1 Y", simpleType.toString());
		annotation = (Annotation) simpleType.annotations().get(1);
		assertEquals("@Marker1", annotation.toString());
		abinding = annotation.resolveAnnotationBinding();
		assertEquals("@Marker1()", abinding.toString());
		
		// for constructor invocation results 2/4
		variableDeclarationStatement = (VariableDeclarationStatement) statements.get(1);
		fragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
		expression = fragment.getInitializer();
		assertEquals("new @Marker1 @Marker2 Outer()", expression.toString());
		simpleType = (SimpleType) ((ClassInstanceCreation)expression).getType();
		assertEquals("@Marker1 @Marker2 Outer", simpleType.toString());
		annotation = (Annotation) simpleType.annotations().get(1);
		assertEquals("@Marker2", annotation.toString());
		abinding = annotation.resolveAnnotationBinding();
		assertEquals("@Marker2()", abinding.toString());
		
		// for constructor invocation results 3/4
		variableDeclarationStatement = (VariableDeclarationStatement) statements.get(2);
		fragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
		expression = fragment.getInitializer();
		assertEquals("o.new @Marker1 @Marker2 Inner()", expression.toString());
		simpleType = (SimpleType) ((ClassInstanceCreation)expression).getType();
		assertEquals("@Marker1 @Marker2 Inner", simpleType.toString());
		annotation = (Annotation) simpleType.annotations().get(1);
		assertEquals("@Marker2", annotation.toString());
		abinding = annotation.resolveAnnotationBinding();
		assertEquals("@Marker2()", abinding.toString());

		// for constructor invocation results 4/4
		variableDeclarationStatement = (VariableDeclarationStatement) statements.get(3);
		fragment = (VariableDeclarationFragment) variableDeclarationStatement.fragments().get(0);
		expression = fragment.getInitializer();
		assertEquals("new <String>@Marker1 @Marker2 ZZ()", expression.toString());
		simpleType = (SimpleType) ((ClassInstanceCreation)expression).getType();
		assertEquals("@Marker1 @Marker2 ZZ", simpleType.toString());
		annotation = (Annotation) simpleType.annotations().get(1);
		assertEquals("@Marker2", annotation.toString());
		abinding = annotation.resolveAnnotationBinding();
		assertEquals("@Marker2()", abinding.toString());

		// annotations on wildcardtypes with TYPE_USE and TYPE_PARAMETER combination.
		WildcardType wildCardType = (WildcardType) type;
		assertEquals("@Marker2 @Marker3 ? super @Marker1 @Marker2 File", wildCardType.toString());
		assertTrue(wildCardType.annotations().size() == 2);
		annotation = (Annotation) wildCardType.annotations().get(1);
		assertEquals("@Marker3", annotation.toString());
		abinding = annotation.resolveAnnotationBinding();
		assertEquals("@Marker3()", abinding.toString());

		// simpleType for  wildcard bounds
		simpleType = (SimpleType) wildCardType.getBound();
		annotation = (Annotation) simpleType.annotations().get(1);
		assertEquals("@Marker2", annotation.toString());
		abinding = annotation.resolveAnnotationBinding();
		assertEquals("@Marker2()", abinding.toString());

		// class declaration with TYPE_PARAMETER annotation
		typedeclaration = (TypeDeclaration) getASTNode(cu, 1);
		typeParameter = (TypeParameter) typedeclaration.typeParameters().get(0);
		assertEquals("@Marker3 T", typeParameter.toString());
		assertTrue(typeParameter.modifiers().size() == 1);
		annotation = (Annotation)typeParameter.modifiers().get(0);
		assertEquals("@Marker3", annotation.toString());
		abinding = annotation.resolveAnnotationBinding();
		assertEquals("@Marker3()", abinding.toString());

		// for type tests
		methodDeclaration = (MethodDeclaration) getASTNode(cu, 1, 0);
		statements = methodDeclaration.getBody().statements();
		statement = (Statement)statements.get(0);
		ConditionalExpression conditionalExpression = (ConditionalExpression)((ReturnStatement)statement).getExpression();
		simpleType = (SimpleType) ((InstanceofExpression)conditionalExpression.getExpression()).getRightOperand();
		assertEquals("@Marker1 @Marker2 File", simpleType.toString());
		assertTrue(simpleType.annotations().size() == 2);
		annotation = (Annotation) simpleType.annotations().get(1);
		assertEquals("@Marker2", annotation.toString());

		// type annotation in front of a constructor declaration
		methodDeclaration = (MethodDeclaration) getASTNode(cu, 3, 0);
		annotation = (Annotation) methodDeclaration.modifiers().get(2);
		assertEquals("@Marker2", annotation.toString());
		abinding = annotation.resolveAnnotationBinding();
		assertEquals("@Marker2()", abinding.toString());

		// type annotation on "this"
		methodDeclaration = (MethodDeclaration) getASTNode(cu, 3, 1);
		simpleType = (SimpleType) methodDeclaration.getReceiverType();
		assertEquals("@Marker2 @Marker1 ZZ", simpleType.toString());
		annotation = (Annotation) simpleType.annotations().get(1);
		assertEquals("@Marker1", annotation.toString());
		abinding = annotation.resolveAnnotationBinding();
		assertEquals("@Marker1()", abinding.toString());
	}

	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793
	 * 
	 * @throws JavaModelException
	 */
	public void test399793a() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test399793/X.java",
				true/* resolve */);
		String contents = "package test399793;"
				+ "interface I {\n"
				+ "	int foo(int x);\n"
				+ "}\n" 
				+ "public class X {\n"
				+ " I i =  vlambda -> {return 200;};\n"
				+"}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1);
		FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0);
		VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0);
		Expression expression = fragment.getInitializer();
		assertTrue(expression instanceof LambdaExpression);
		LambdaExpression lambdaExpression = (LambdaExpression)expression;
		assertEquals("vlambda -> {\n  return 200;\n}\n", lambdaExpression.toString());
		assertTrue(lambdaExpression.parameters().size() == 1);
		IMethodBinding binding = lambdaExpression.resolveMethodBinding();
		assertEquals("private static int lambda$0(int) ", binding.toString());
		VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0);
		assertTrue(variableDeclaration instanceof VariableDeclarationFragment);
		fragment = (VariableDeclarationFragment)variableDeclaration;
		assertEquals("vlambda", fragment.toString());		
		IVariableBinding variableBinding = fragment.resolveBinding();		
		ITypeBinding typeBinding = variableBinding.getType();
		assertNotNull("Null Binding for lambda argument", typeBinding);
		assertEquals("binding of int expected for lambda","int",typeBinding.getName());
	}

	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793
	 * 
	 * @throws JavaModelException
	 */
	public void test399793b() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test399793/X.java",
				true/* resolve */);
		String contents = "package test399793;"
				+ "interface I {\n"
				+ "	int foo(int x);\n"
				+ "}\n" 
				+ "public class X {\n"
				+ " I i =  vlambda -> 200;\n"
				+"}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1);
		FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0);
		VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0);
		Expression expression = fragment.getInitializer();
		assertTrue(expression instanceof LambdaExpression);
		LambdaExpression lambdaExpression = (LambdaExpression)expression;
		assertEquals("vlambda -> 200", lambdaExpression.toString());
		IMethodBinding binding = lambdaExpression.resolveMethodBinding();
		assertEquals("private static int lambda$0(int) ", binding.toString());
		assertTrue(lambdaExpression.parameters().size() == 1);
		VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0);
		assertTrue(variableDeclaration instanceof VariableDeclarationFragment);
		fragment = (VariableDeclarationFragment)variableDeclaration;
		assertEquals("vlambda", fragment.toString());		
	}
	
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793
	 * 
	 * @throws JavaModelException
	 */
	public void test399793c() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test399793/X.java",
				true/* resolve */);
		String contents = "package test399793;"
				+ "interface I {\n"
				+ "	Object foo(int [] ia);\n"
				+ "}\n" 
				+ "public class X {\n"
				+ " I i = (int [] ia) ->{\n"
				+ "  	return ia.clone();"
				+ "};\n"
				+"}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1);
		FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0);
		VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0);
		Expression expression = fragment.getInitializer();
		assertTrue(expression instanceof LambdaExpression);
		LambdaExpression lambdaExpression = (LambdaExpression)expression;
		assertEquals("(int[] ia) -> {\n  return ia.clone();\n}\n", lambdaExpression.toString());
		IMethodBinding binding = lambdaExpression.resolveMethodBinding();
		assertEquals("private static java.lang.Object lambda$0(int[]) ", binding.toString());
		assertTrue(lambdaExpression.parameters().size() == 1);
		VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0);
		assertTrue(variableDeclaration instanceof SingleVariableDeclaration);
		SingleVariableDeclaration singleVariableDeclaration = (SingleVariableDeclaration)variableDeclaration;
		assertEquals("int[] ia", singleVariableDeclaration.toString());
	}

	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793
	 * 
	 * @throws JavaModelException
	 */
	public void test399793d() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test399793/X.java",
				true/* resolve */);
		String contents = "package test399793;" +
				"interface I {\n" +
				"	void doit();\n" +
				"}\n" +
				"public class X {\n" +
				"		I i = () -> {\n" +
				"			System.out.println(this);\n" +
				"			I j = () -> {\n" +
				"				System.out.println(this);\n" +
				"				I k = () -> {\n" +
				"					System.out.println(this);\n" +
				"				};\n" +
				"			};\n" +
				"		};\n" +
				"	}\n"; 
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1);
		FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0);
		VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0);
		IVariableBinding variableBinding = fragment.resolveBinding();
		assertEquals("test399793.I i", variableBinding.toString());
		Expression expression = fragment.getInitializer();
		assertTrue(expression instanceof LambdaExpression);
		LambdaExpression lambdaExpression = (LambdaExpression)expression;
		assertEquals("() -> {\n  System.out.println(this);\n  I j=() -> {\n    System.out.println(this);\n    I k=() -> {\n      System.out.println(this);\n    }\n;\n  }\n;\n}\n", lambdaExpression.toString());
		IMethodBinding binding = lambdaExpression.resolveMethodBinding();
		assertEquals("private void lambda$0() ", binding.toString());
		assertTrue(lambdaExpression.parameters().size() == 0);
	}

	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399794
	 * ReferenceExpression Family Tests
	 * 
	 * @throws JavaModelException
	 */
	public void test399794() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test399794/X.java",
				true/* resolve */);
		String contents = "package test399794;" +
				"import java.lang.annotation.*;\n " +
				"interface I {\n" +
				"    Object copy(int [] ia);\n" +
				"}\n" +
				"interface J {\n" +
				"	void foo(int x);\n" +
				"}\n" +
				"class XX {\n" +
				"	public  void foo(int x) {}\n" +
				"}\n" +
				"\n" +
				"class Y {\n" +
				"       static class Z {\n" +
				"               public static void foo(int x) {\n" +
				"                       System.out.print(x);\n" +
				"               }\n" +
				"       }\n" +
				"       public void foo(int x) {\n" +
				"               System.out.print(x);\n" +
				"       }\n" +
				"		public <T> void foo(T t){t.hashCode();}\n" +
				"}\n" +
				"\n" +
				"public class X extends XX {\n" +
				"       @SuppressWarnings(\"unused\")\n" +
				"       public  void bar(String [] args) {\n" +
				"                Y y = new Y();\n" +
				"                I i = @Marker int []::<String>clone;\n" +
				"                J j = Y.@Marker Z  :: foo;\n" +
				"                J j1 = Y.@Marker Z  :: <String> foo;\n" +
				"                J jdash = @Marker W<@Marker Integer> :: <String> new ;\n" +
				"                J jj = y :: foo;\n" +
				"                J jx = super ::  foo;\n" +
				"		 	     class Z {\n" +
				"					void foo() {\n" +
				"						J jz = X.super :: foo;\n" +
		    	"					}\n" +
				"				}\n" +		
				"       }\n" +
				"       public static void main (String [] args) {}\n" +
				"}\n" +
				"class W<T> extends Y {\n" +
				"       public W(T x) {}\n" +
				"}\n" +
				"\n" +
				"@Target (ElementType.TYPE_USE)\n" +
				"@interface Marker {}";
			
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typeDeclaration = (TypeDeclaration) getASTNode(cu, 4);
		MethodDeclaration method = typeDeclaration.getMethods()[0];
		List statements = method.getBody().statements();
		assertTrue(statements.size() == 8);
		int fCount = 1;
		
		// type method reference with primitive type with type arguments
		VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(fCount++);
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) statement.fragments().get(0);
		Expression expression = fragment.getInitializer();
		assertTrue(expression instanceof TypeMethodReference);
		TypeMethodReference typeMethodReference = (TypeMethodReference) expression;
		checkSourceRange(typeMethodReference, "@Marker int []::<String>clone", contents);
		ITypeBinding typeBinding = typeMethodReference.resolveTypeBinding();
		assertNotNull(typeBinding);
		IMethodBinding methodBinding = typeMethodReference.resolveMethodBinding();
		assertNotNull(methodBinding);
		Type type = typeMethodReference.getType();
		checkSourceRange(type, "@Marker int []", contents);
		assertTrue(type.isArrayType());
		List typeArguments = typeMethodReference.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		checkSourceRange(type, "String", contents);
		assertTrue(type.isSimpleType());
		SimpleName name = typeMethodReference.getName();
		checkSourceRange(name, "clone", contents);
		typeBinding = name.resolveTypeBinding();
		assertNotNull(typeBinding);

		// type method reference with qualified type without type arguments
		statement = (VariableDeclarationStatement) statements.get(fCount++);
		fragment = (VariableDeclarationFragment) statement.fragments().get(0);
		expression = fragment.getInitializer();
		assertTrue(expression instanceof TypeMethodReference);
		typeMethodReference = (TypeMethodReference) expression;
		checkSourceRange(typeMethodReference, "Y.@Marker Z  :: foo", contents);
		typeBinding = typeMethodReference.resolveTypeBinding();
		assertNotNull(typeBinding);
		methodBinding = typeMethodReference.resolveMethodBinding();
		assertNotNull(methodBinding);
		type = typeMethodReference.getType();
		assertTrue(type.isNameQualifiedType());
		checkSourceRange(type, "Y.@Marker Z", contents);
		typeArguments = typeMethodReference.typeArguments();
		assertTrue(typeArguments.size() == 0);
		name = typeMethodReference.getName();
		checkSourceRange(name, "foo", contents);
		typeBinding = name.resolveTypeBinding();
		assertNotNull(typeBinding);

		// type method reference with qualified type with type arguments
		statement = (VariableDeclarationStatement) statements.get(fCount++);
		fragment = (VariableDeclarationFragment) statement.fragments().get(0);
		expression = fragment.getInitializer();
		assertTrue(expression instanceof TypeMethodReference);
		typeMethodReference = (TypeMethodReference) expression;
		checkSourceRange(typeMethodReference, "Y.@Marker Z  :: <String> foo", contents);
		typeBinding = typeMethodReference.resolveTypeBinding();
		assertNotNull(typeBinding);
		methodBinding = typeMethodReference.resolveMethodBinding();
		assertNotNull(methodBinding);
		type = typeMethodReference.getType();
		assertTrue(type.isNameQualifiedType());
		checkSourceRange(type, "Y.@Marker Z", contents);
		typeArguments = typeMethodReference.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertTrue(type.isSimpleType());
		checkSourceRange(type, "String", contents);
		name = typeMethodReference.getName();
		checkSourceRange(name, "foo", contents);
		typeBinding = name.resolveTypeBinding();
		assertNotNull(typeBinding);

		// creation method reference
		statement = (VariableDeclarationStatement) statements.get(fCount++);
		fragment = (VariableDeclarationFragment) statement.fragments().get(0);
		expression = fragment.getInitializer();
		assertTrue(expression instanceof CreationReference);
		CreationReference creationReference = (CreationReference) expression;
		checkSourceRange(creationReference, "@Marker W<@Marker Integer> :: <String> new", contents);
		typeBinding = creationReference.resolveTypeBinding();
		assertNotNull(typeBinding);
		methodBinding = creationReference.resolveMethodBinding();
		assertNotNull(methodBinding);
		type = creationReference.getType();
		checkSourceRange(type, "@Marker W<@Marker Integer>", contents);
		assertTrue(type instanceof ParameterizedType);
		assertASTNodeEquals("@Marker W<@Marker Integer>", type);
		typeArguments = creationReference.typeArguments();
		assertTrue(typeArguments.size() == 1);
		type = (Type) typeArguments.get(0);
		assertTrue(type.isSimpleType());
		checkSourceRange(type, "String", contents);

		// expression method reference
		statement = (VariableDeclarationStatement) statements.get(fCount++);
		fragment = (VariableDeclarationFragment) statement.fragments().get(0);
		expression = fragment.getInitializer();
		assertTrue(expression instanceof ExpressionMethodReference);
		ExpressionMethodReference expressionMethodReference = (ExpressionMethodReference) expression;
		checkSourceRange(expressionMethodReference, "y :: foo", contents);
		typeBinding = expressionMethodReference.resolveTypeBinding();
		assertNotNull(typeBinding);
		methodBinding = expressionMethodReference.resolveMethodBinding();
		assertNotNull(methodBinding);
		Expression lhs = expressionMethodReference.getExpression();
		checkSourceRange(lhs, "y", contents);
		typeArguments = expressionMethodReference.typeArguments();
		assertTrue(typeArguments.size() == 0);
		name = expressionMethodReference.getName();
		checkSourceRange(name, "foo", contents);
		typeBinding = name.resolveTypeBinding();
		assertNotNull(typeBinding);

		// super method reference without qualifier
		statement = (VariableDeclarationStatement) statements.get(fCount++);
		fragment = (VariableDeclarationFragment) statement.fragments().get(0);
		expression = fragment.getInitializer();
		assertTrue(expression instanceof SuperMethodReference);
		SuperMethodReference superMethodReference = (SuperMethodReference) expression;
		checkSourceRange(superMethodReference, "super ::  foo", contents);
		typeBinding = superMethodReference.resolveTypeBinding();
		assertNotNull(typeBinding);
		methodBinding = superMethodReference.resolveMethodBinding();
		assertNotNull(methodBinding);
		assertNull(superMethodReference.getQualifier());		
		typeArguments = superMethodReference.typeArguments();
		assertTrue(typeArguments.size() == 0);
		name = superMethodReference.getName();
		checkSourceRange(name, "foo", contents);
		typeBinding = name.resolveTypeBinding();
		assertNotNull(typeBinding);

		// super method reference with qualifier
		TypeDeclarationStatement typeDeclarationStatement = (TypeDeclarationStatement) statements.get(fCount);
		typeDeclaration = (TypeDeclaration) typeDeclarationStatement.getDeclaration();
		method = typeDeclaration.getMethods()[0];
		statements = method.getBody().statements();
		assertTrue(statements.size() == 1);
		statement = (VariableDeclarationStatement) statements.get(0);
		fragment = (VariableDeclarationFragment) statement.fragments().get(0);
		expression = fragment.getInitializer();
		assertTrue(expression instanceof SuperMethodReference);
		superMethodReference = (SuperMethodReference) expression;
		checkSourceRange(superMethodReference, "X.super :: foo", contents);
		typeBinding = superMethodReference.resolveTypeBinding();
		assertNotNull(typeBinding);
		methodBinding = superMethodReference.resolveMethodBinding();
		assertNotNull(methodBinding);
		name = (SimpleName) superMethodReference.getQualifier();
		checkSourceRange(name, "X", contents);		
		typeArguments = superMethodReference.typeArguments();
		assertTrue(typeArguments.size() == 0);
		name = superMethodReference.getName();
		checkSourceRange(name, "foo", contents);
		typeBinding = name.resolveTypeBinding();
		assertNotNull(typeBinding);
	
	}
	
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=399793
	 * 
	 * @throws JavaModelException
	 */
	public void test399793e() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test399793/X.java",
				true/* resolve */);
		String contents = "package test399793;" +
				"interface I {\n" +
				"  J foo();\n" +
				"}\n" +
				"interface J {\n" +
				"  int foo();\n" +
				"}\n" +
				"public class X {\n" +
				"    I I = () -> () -> 10;\n" +
				"}\n";
			
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 2);
		FieldDeclaration fieldDeclaration = (FieldDeclaration) typedeclaration.bodyDeclarations().get(0);
		VariableDeclarationFragment fragment = (VariableDeclarationFragment)fieldDeclaration.fragments().get(0);
		Expression expression = fragment.getInitializer();
		assertTrue(expression instanceof LambdaExpression);
		LambdaExpression lambdaExpression = (LambdaExpression)expression;
		assertEquals("() -> () -> 10", lambdaExpression.toString());
		IMethodBinding binding = lambdaExpression.resolveMethodBinding();
		assertEquals("private static test399793.J lambda$0() ", binding.toString());
		assertTrue(lambdaExpression.parameters().size() == 0);
	}	
	
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=402665
	 * 
	 * @throws JavaModelException
	 */
	public void test402665a() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test402665/X.java",
				true/* resolve */);
		String contents = "package test402665;" +
				"public class X {\n" +
				"  public static interface StringToInt {\n" +
				"   	int stoi(String s);\n" +
				"  }\n" +
				"  public static interface ReduceInt {\n" +
				"      int reduce(int a, int b);\n" +
				"  }\n" +
				"  void foo(StringToInt s) { }\n" +
				"  void bar(ReduceInt r) { }\n" +
				"  void bar() {\n" +
				"      foo(s -> s.length());\n" +
				"      foo((s) -> s.length());\n" +
				"      foo((String s) -> s.length()); //SingleVariableDeclaration is OK\n" +
				"      bar((x, y) -> x+y);\n" +
				"      bar((int x, int y) -> x+y); //SingleVariableDeclarations are OK\n" +
				"  }\n" +
				"}\n";
			
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0);
		MethodDeclaration methoddecl = (MethodDeclaration)typedeclaration.bodyDeclarations().get(4);
		List statements = methoddecl.getBody().statements();
		int sCount = 0;
		
		ExpressionStatement statement = (ExpressionStatement)statements.get(sCount++);
		MethodInvocation methodInvocation = (MethodInvocation)statement.getExpression();
		LambdaExpression lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0);
		VariableDeclarationFragment fragment = (VariableDeclarationFragment)lambdaExpression.parameters().get(0);
		checkSourceRange(fragment, "s", contents);
		
		statement = (ExpressionStatement)statements.get(sCount++);
		methodInvocation = (MethodInvocation)statement.getExpression();
		lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0);
		fragment = (VariableDeclarationFragment)lambdaExpression.parameters().get(0);
		checkSourceRange(fragment, "s", contents);

		statement = (ExpressionStatement)statements.get(sCount++);
		methodInvocation = (MethodInvocation)statement.getExpression();
		lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0);
		SingleVariableDeclaration singleVarDecl = (SingleVariableDeclaration)lambdaExpression.parameters().get(0);
		checkSourceRange(singleVarDecl, "String s", contents);

		statement = (ExpressionStatement)statements.get(sCount++);
		methodInvocation = (MethodInvocation)statement.getExpression();
		lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0);
		fragment = (VariableDeclarationFragment)lambdaExpression.parameters().get(0);
		checkSourceRange(fragment, "x", contents);
		fragment = (VariableDeclarationFragment)lambdaExpression.parameters().get(1);
		checkSourceRange(fragment, "y", contents);

		statement = (ExpressionStatement)statements.get(sCount++);
		methodInvocation = (MethodInvocation)statement.getExpression();
		lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0);
		singleVarDecl = (SingleVariableDeclaration)lambdaExpression.parameters().get(0);
		checkSourceRange(singleVarDecl, "int x", contents);
		singleVarDecl = (SingleVariableDeclaration)lambdaExpression.parameters().get(1);
		checkSourceRange(singleVarDecl, "int y", contents);
	}
	public void testBug403132() throws JavaModelException {
		String contents =
			"import java.lang.annotation.*;\n" +
			"public class X {\n" +
			"	class Y {\n" +
			"		class Z {\n" +
			"			public Z(@A X.@B Y Y.this,String str){\n}" +
			"    	 	public void foo(@A X.@B Y.@C Z this,String str){\n}\n" +
			"		}\n" +
			"    }\n" +
			"}\n" +
			"@Target(ElementType.TYPE_USE)\n" +
			"@interface A {}\n" +
			"@Target(ElementType.TYPE_USE)\n" +
			"@interface B {}\n" +
			"@Target(ElementType.TYPE_USE)\n" +
			"@interface C {}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		node = getASTNode(unit, 0, 0);
		TypeDeclaration type = (TypeDeclaration)node;
		node = (ASTNode) type.bodyDeclarations().get(0);
		type = (TypeDeclaration) node;
		node = (ASTNode) type.bodyDeclarations().get(0);
		assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		MethodDeclaration method = (MethodDeclaration) node;
		Type receiver = method.getReceiverType();
		assertEquals("Not a qualified type", ASTNode.QUALIFIED_TYPE, receiver.getNodeType());
		assertEquals("Incorrect receiver", "@A X.@B Y", ((QualifiedType) receiver).toString());
		assertEquals("Incorrect method signature", "public Z(@A X.@B Y Y.this,String str){\n}\n", method.toString());

		method = (MethodDeclaration) type.bodyDeclarations().get(1);
		receiver = method.getReceiverType();
		assertEquals("Incorrect receiver", "@A X.@B Y.@C Z", ((QualifiedType) receiver).toString());
		assertEquals("Incorrect method signature", "public void foo(@A X.@B Y.@C Z this,String str){\n}\n", method.toString());
	}
	public void testParameterizedReceiverType() throws JavaModelException {
		String contents =
				"import java.lang.annotation.*;\n" +
						"public class X<T extends Exception> {\n" +
						"	class Y<K, V> {\n" +
						"		class Z {\n" +
						"			public Z(@A X<T>.@B Y<K, V> Y.this, boolean a){ }\n" +
						"			public void foo(@B Y<K, V>.@C Z this, boolean a){ }\n" +
						"			public Z(X<T>.@B Y<K, V> Y.this){ }\n" +
						"			public void foo(Y<K, V>.@C Z this){ }\n" +
						"		}\n" +
						"	}\n" +
						"}\n" +
						"@Target(ElementType.TYPE_USE)\n" +
						"@interface A {}\n" +
						"@Target(ElementType.TYPE_USE)\n" +
						"@interface B {}\n" +
						"@Target(ElementType.TYPE_USE)\n" +
						"@interface C {}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		node = getASTNode(unit, 0, 0);
		TypeDeclaration type = (TypeDeclaration)node;
		node = (ASTNode) type.bodyDeclarations().get(0);
		type = (TypeDeclaration) node;
		
		MethodDeclaration method = (MethodDeclaration) type.bodyDeclarations().get(0);
		Type receiver = method.getReceiverType();
		assertEquals("Not a ParameterizedType", ASTNode.PARAMETERIZED_TYPE, receiver.getNodeType());
		checkSourceRange(receiver, "@A X<T>.@B Y<K, V>", contents);
		assertEquals("Incorrect method signature", "public Z(@A X<T>.@B Y<K,V> Y.this,boolean a){\n}\n", method.toString());
		
		method = (MethodDeclaration) type.bodyDeclarations().get(1);
		receiver = method.getReceiverType();
		assertEquals("Not a QualifiedType", ASTNode.QUALIFIED_TYPE, receiver.getNodeType());
		checkSourceRange(receiver, "@B Y<K, V>.@C Z", contents);
		assertEquals("Incorrect method signature", "public void foo(@B Y<K,V>.@C Z this,boolean a){\n}\n", method.toString());
		
		method = (MethodDeclaration) type.bodyDeclarations().get(2);
		receiver = method.getReceiverType();
		assertEquals("Not a ParameterizedType", ASTNode.PARAMETERIZED_TYPE, receiver.getNodeType());
		checkSourceRange(receiver, "X<T>.@B Y<K, V>", contents);
		assertEquals("Incorrect method signature", "public Z(X<T>.@B Y<K,V> Y.this){\n}\n", method.toString());
		
		method = (MethodDeclaration) type.bodyDeclarations().get(3);
		receiver = method.getReceiverType();
		assertEquals("Not a QualifiedType", ASTNode.QUALIFIED_TYPE, receiver.getNodeType());
		checkSourceRange(receiver, "Y<K, V>.@C Z", contents);
		assertEquals("Incorrect method signature", "public void foo(Y<K,V>.@C Z this){\n}\n", method.toString());
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=403410
	public void testBug403410() throws JavaModelException {
		String contents =
			"import java.lang.annotation.*;\n" +
			"public class X {\n" +
			"	class Y {\n" +
			"		class Z {\n" +
			"			public Z(final Y Y.this){\n}" +
			"    	 	public void foo(static @A Z this){\n}\n" +
			"		}\n" +
			"    }\n" +
			"}\n" +
			"@Target(ElementType.TYPE_USE)\n" +
			"@interface A {}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", false);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		node = getASTNode(unit, 0, 0);
		TypeDeclaration type = (TypeDeclaration)node;
		node = (ASTNode) type.bodyDeclarations().get(0);
		type = (TypeDeclaration) node;
		node = (ASTNode) type.bodyDeclarations().get(0);
		assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		MethodDeclaration method = (MethodDeclaration) node;
		assertEquals("Type should be malformed", ASTNode.MALFORMED, (method.getFlags() & ASTNode.MALFORMED));

		method = (MethodDeclaration) type.bodyDeclarations().get(1);
		assertEquals("Type should be malformed", ASTNode.MALFORMED, (method.getFlags() & ASTNode.MALFORMED));
	}
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=402674
	 * 
	 * @throws JavaModelException
	 */
	public void test402674() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test402674/X.java",
				true/* resolve */);
		String contents = "package test402674;" +
				"public class X {\n" +
				"  public static interface StringToInt {\n" +
				"   	int stoi(String s);\n" +
				"  }\n" +
				"  public static interface ReduceInt {\n" +
				"      int reduce(int a, int b);\n" +
				"  }\n" +
				"  void foo(StringToInt s) { }\n" +
				"  void bar(ReduceInt r) { }\n" +
				"  void bar() {\n" +
				"      foo(s -> s.length());\n" +
				"      foo((s) -> s.length());\n" +
				"      foo((String s) -> s.length()); //SingleVariableDeclaration is OK\n" +
				"      bar((x, y) -> x+y);\n" +
				"      bar((int x, int y) -> x+y); //SingleVariableDeclarations are OK\n" +
				"  }\n" +
				"}\n";
			
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0);
		MethodDeclaration methoddecl = (MethodDeclaration)typedeclaration.bodyDeclarations().get(4);
		List statements = methoddecl.getBody().statements();
		int sCount = 0;
		
		ExpressionStatement statement = (ExpressionStatement)statements.get(sCount++);
		MethodInvocation methodInvocation = (MethodInvocation)statement.getExpression();
		LambdaExpression lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0);
		ITypeBinding binding = lambdaExpression.resolveTypeBinding();
		assertNotNull(binding);
		assertEquals("StringToInt", binding.getName());
		
		statement = (ExpressionStatement)statements.get(sCount++);
		methodInvocation = (MethodInvocation)statement.getExpression();
		lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0);
		binding = lambdaExpression.resolveTypeBinding();
		assertNotNull(binding);
		assertEquals("StringToInt", binding.getName());

		statement = (ExpressionStatement)statements.get(sCount++);
		methodInvocation = (MethodInvocation)statement.getExpression();
		lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0);
		binding = lambdaExpression.resolveTypeBinding();
		assertNotNull(binding);
		assertEquals("StringToInt", binding.getName());

		statement = (ExpressionStatement)statements.get(sCount++);
		methodInvocation = (MethodInvocation)statement.getExpression();
		lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0);
		binding = lambdaExpression.resolveTypeBinding();
		assertNotNull(binding);
		assertEquals("ReduceInt", binding.getName());

		statement = (ExpressionStatement)statements.get(sCount++);
		methodInvocation = (MethodInvocation)statement.getExpression();
		lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0);
		binding = lambdaExpression.resolveTypeBinding();
		assertNotNull(binding);
		assertEquals("ReduceInt", binding.getName());
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=399791
	public void testBug399791() throws JavaModelException {
		String contents =
			"public interface X {\n" +
			"	static void foo(){}\n" +
			"   public default void foo(int i){}\n" +
			"   native void foo(float f){}\n" +
			"   abstract void foo(long l){}\n" +
			"}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", false);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		TypeDeclaration type =  (TypeDeclaration) unit.types().get(0);
		node = (ASTNode) type.bodyDeclarations().get(0);
		assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		MethodDeclaration method = (MethodDeclaration) node;
		assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED));
		List modifiers = method.modifiers();
		assertEquals("Incorrect no of modfiers", 1, modifiers.size());
		Modifier modifier = (Modifier) modifiers.get(0);
		assertSame("Incorrect modifier keyword", Modifier.ModifierKeyword.STATIC_KEYWORD, modifier.getKeyword());

		method = (MethodDeclaration) type.bodyDeclarations().get(1);
		assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED));

		modifiers = method.modifiers();
		assertEquals("Incorrect no of modfiers", 2, modifiers.size());
		modifier = (Modifier) modifiers.get(1);
		assertSame("Incorrect modifier keyword", Modifier.ModifierKeyword.DEFAULT_KEYWORD, modifier.getKeyword());
		assertTrue("Incorrect modifier", modifier.isDefault());
		assertEquals("Incorrect AST", "public default void foo(int i){\n}\n", method.toString());

		method = (MethodDeclaration) type.bodyDeclarations().get(2);
		assertEquals("Method should be malformed", ASTNode.MALFORMED, (method.getFlags() & ASTNode.MALFORMED));

		method = (MethodDeclaration) type.bodyDeclarations().get(3);
		assertEquals("Method should be malformed", ASTNode.MALFORMED, (method.getFlags() & ASTNode.MALFORMED));
	}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=404489
	public void testBug404489a() throws JavaModelException {
		String contents =
		"package test404489.bug;\n" +
		"public class X { \n" +
		"	class Y { \n" +
		"		class Z {\n" +
		"			public Z(@A X.@B Y Y.this){}\n" +
		"			}\n" +
		"  		}\n" +
		"  		Object o=(@A X.@B Y.@Marker  Z)null;\n" +
		"	}\n" +
		"@java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE) @interface Marker {} \n" +
		"@java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE) @interface A {} \n" +
		"@java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE) @interface B {} \n";
		this.workingCopy = getWorkingCopy("/Converter18/src/test404489/bug/X.java", true/* resolve */);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		TypeDeclaration type =  (TypeDeclaration) unit.types().get(0);
		node = (ASTNode) type.bodyDeclarations().get(0);
		assertEquals("Not a Type Declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		node = (ASTNode) ((TypeDeclaration)node).bodyDeclarations().get(0);
		assertEquals("Not a Type Declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		node = (ASTNode) ((TypeDeclaration)node).bodyDeclarations().get(0);		
		assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		MethodDeclaration method = (MethodDeclaration) node;
		assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED));
		Type annotatableType = method.getReceiverType();
		assertTrue(annotatableType.isQualifiedType());
		QualifiedType qualifiedType = (QualifiedType) annotatableType;
		assertEquals("wrong qualified type", "@A X.@B Y", qualifiedType.toString());
		ITypeBinding binding = qualifiedType.resolveBinding();
		assertNotNull("No binding", binding);
		assertEquals("Wrong qualified name", "test404489.bug.X.Y", binding.getQualifiedName());
		SimpleType simpleType = (SimpleType) qualifiedType.getQualifier();
		assertEquals("incorrect type", "@A X", simpleType.toString());
		binding = simpleType.resolveBinding();
		assertNotNull("No binding", binding);
		assertEquals("Wrong qualified name", "test404489.bug.X", binding.getQualifiedName());
		List annotations = qualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		MarkerAnnotation marker	= (MarkerAnnotation) annotations.get(0);
		assertEquals("wrong annotation name", "@B", marker.toString());
		binding = marker.resolveTypeBinding();
		assertNotNull("No binding", binding);
		assertEquals("Wrong qualified name", "test404489.bug.B", binding.getQualifiedName());
		IAnnotationBinding annotationBinding = marker.resolveAnnotationBinding();
		assertNotNull(annotationBinding);
		assertEquals("wrong annotation binding", "B", annotationBinding.getName());
		Name name = marker.getTypeName();
		assertTrue(name.isSimpleName());
		SimpleName simpleName = (SimpleName) name;
		assertEquals("wrong type name", "B", simpleName.toString());
		assertEquals("wrong simple name", "B",simpleName.getIdentifier());
		binding = simpleName.resolveTypeBinding();
		assertNotNull("No binding", binding);
		assertEquals("Wrong qualified name", "test404489.bug.B", binding.getQualifiedName());
		assertTrue(qualifiedType.getQualifier().isSimpleType());
		simpleType = (SimpleType) qualifiedType.getQualifier();
		assertEquals("incorrect type", "@A X", simpleType.toString());
		binding = simpleType.resolveBinding();
		assertNotNull("No binding", binding);
		assertEquals("Wrong qualified name", "test404489.bug.X", binding.getQualifiedName());
	}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=404489
	public void testBug404489b() throws JavaModelException {
		ICompilationUnit sourceUnit = getCompilationUnit("Converter18" , "src", "test404489.bug", "X.java"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
		ASTNode result = runConversion(this.ast.apiLevel(), sourceUnit, true);
		char[] source = sourceUnit.getSource().toCharArray();
		assertTrue("Not a compilation unit", result.getNodeType() == ASTNode.COMPILATION_UNIT);
		CompilationUnit compilationUnit = (CompilationUnit) result;
		assertProblemsSize(compilationUnit, 0);
		ASTNode node = getASTNode(compilationUnit, 0, 0, 0);
		TypeDeclaration typeDeclaration =  (TypeDeclaration) compilationUnit.types().get(0);

		node = (ASTNode) typeDeclaration.bodyDeclarations().get(2);
		assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());		
		MethodDeclaration methodDecl = (MethodDeclaration) node;
		Type type = methodDecl.getReturnType2();
		assertTrue(type.isNameQualifiedType());
		NameQualifiedType nameQualifiedType = (NameQualifiedType) type;
		checkSourceRange(nameQualifiedType, "test404489.bug.@NonNull IOException", source);
		ITypeBinding typeBinding = nameQualifiedType.resolveBinding();
		assertNotNull("null binding", typeBinding);
		assertEquals("not a valid binding", "test404489.bug.IOException", typeBinding.getQualifiedName());
		
		// qualifier of the name qualified type
		Name name = nameQualifiedType.getQualifier();
		assertTrue(name.isQualifiedName());
		QualifiedName qualifiedName = (QualifiedName) name;
		checkSourceRange(qualifiedName, "test404489.bug", source);
		typeBinding = qualifiedName.resolveTypeBinding();
		assertNull(typeBinding);
		IBinding binding = qualifiedName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489.bug", binding.toString());
		name = qualifiedName.getQualifier();
		assertTrue("wrong name type", name.isSimpleName());
		SimpleName simpleName = (SimpleName) name;
		checkSourceRange(simpleName, "test404489", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNull(typeBinding);
		binding = simpleName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489", binding.toString());
		simpleName = qualifiedName.getName();
		checkSourceRange(simpleName, "bug", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNull(typeBinding);
		binding = simpleName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489.bug", binding.toString());
		
		// annotations of name qualified type
		List annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		Annotation annotation = (Annotation) annotations.get(0);
		typeBinding = annotation.resolveTypeBinding();
		assertNotNull("null binding", typeBinding);
		assertEquals("not a valid binding", "test404489.bug.X.NonNull", typeBinding.getQualifiedName());
		IAnnotationBinding annotationBinding = annotation.resolveAnnotationBinding();
		assertEquals("not a valid annotation binding", "@NonNull()", annotationBinding.toString());
		name = annotation.getTypeName();
		assertTrue(name.isSimpleName());
		simpleName = (SimpleName) name;
		typeBinding = simpleName.resolveTypeBinding();
		checkSourceRange(simpleName, "NonNull", source);
		assertNotNull(typeBinding);
		
		// name of the name qualified type
		simpleName = nameQualifiedType.getName();
		checkSourceRange(simpleName, "IOException", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNotNull(typeBinding);
		
		// parameter
		SingleVariableDeclaration param = (SingleVariableDeclaration) methodDecl.parameters().get(0);
		type = param.getType();
		assertTrue(type.isNameQualifiedType());
		nameQualifiedType = (NameQualifiedType) type;
		checkSourceRange(nameQualifiedType, "test404489.bug.@NonNull FileNotFoundException", source);
		typeBinding = nameQualifiedType.resolveBinding();
		assertNotNull("null binding", typeBinding);
		assertEquals("not a valid binding", "test404489.bug.FileNotFoundException", typeBinding.getQualifiedName());
		
		// qualifier of the name qualified type
		name = nameQualifiedType.getQualifier();
		assertTrue(name.isQualifiedName());
		qualifiedName = (QualifiedName) name;
		checkSourceRange(qualifiedName, "test404489.bug", source);
		typeBinding = qualifiedName.resolveTypeBinding();
		assertNull(typeBinding);
		binding = qualifiedName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489.bug", binding.toString());
		name = qualifiedName.getQualifier();
		assertTrue("wrong name type", name.isSimpleName());
		simpleName = (SimpleName) name;
		checkSourceRange(simpleName, "test404489", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNull(typeBinding);
		binding = simpleName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489", binding.toString());
		simpleName = qualifiedName.getName();
		checkSourceRange(simpleName, "bug", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNull(typeBinding);
		binding = simpleName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489.bug", binding.toString());
		
		// annotations of name qualified type
		annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		typeBinding = annotation.resolveTypeBinding();
		assertNotNull("null binding", typeBinding);
		assertEquals("not a valid binding", "test404489.bug.X.NonNull", typeBinding.getQualifiedName());
		annotationBinding = annotation.resolveAnnotationBinding();
		assertEquals("not a valid annotation binding", "@NonNull()", annotationBinding.toString());
		name = annotation.getTypeName();
		assertTrue(name.isSimpleName());
		simpleName = (SimpleName) name;
		typeBinding = simpleName.resolveTypeBinding();
		checkSourceRange(simpleName, "NonNull", source);
		assertNotNull(typeBinding);
		
		// name of the name qualified type
		simpleName = nameQualifiedType.getName();
		checkSourceRange(simpleName, "FileNotFoundException", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNotNull(typeBinding);
		
		// throws
		type = (Type) methodDecl.thrownExceptionTypes().get(0);
		assertTrue(type.isNameQualifiedType());
		nameQualifiedType = (NameQualifiedType) type;
		checkSourceRange(nameQualifiedType, "test404489.bug.@NonNull EOFException", source);
		typeBinding = nameQualifiedType.resolveBinding();
		assertNotNull("null binding", typeBinding);
		assertEquals("not a valid binding", "test404489.bug.EOFException", typeBinding.getQualifiedName());
		
		// qualifier of the name qualified type
		name = nameQualifiedType.getQualifier();
		assertTrue(name.isQualifiedName());
		qualifiedName = (QualifiedName) name;
		checkSourceRange(qualifiedName, "test404489.bug", source);
		typeBinding = qualifiedName.resolveTypeBinding();
		assertNull(typeBinding);
		binding = qualifiedName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489.bug", binding.toString());
		name = qualifiedName.getQualifier();
		assertTrue("wrong name type", name.isSimpleName());
		simpleName = (SimpleName) name;
		checkSourceRange(simpleName, "test404489", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNull(typeBinding);
		binding = simpleName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489", binding.toString());
		simpleName = qualifiedName.getName();
		checkSourceRange(simpleName, "bug", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNull(typeBinding);
		binding = simpleName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489.bug", binding.toString());
		
		// annotations of name qualified type
		annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		typeBinding = annotation.resolveTypeBinding();
		assertNotNull("null binding", typeBinding);
		assertEquals("not a valid binding", "test404489.bug.X.NonNull", typeBinding.getQualifiedName());
		annotationBinding = annotation.resolveAnnotationBinding();
		assertEquals("not a valid annotation binding", "@NonNull()", annotationBinding.toString());
		name = annotation.getTypeName();
		assertTrue(name.isSimpleName());
		simpleName = (SimpleName) name;
		typeBinding = simpleName.resolveTypeBinding();
		checkSourceRange(simpleName, "NonNull", source);
		assertNotNull(typeBinding);
		
		// name of the name qualified type
		simpleName = nameQualifiedType.getName();
		checkSourceRange(simpleName, "EOFException", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNotNull(typeBinding);

		node = (ASTNode) typeDeclaration.bodyDeclarations().get(3);
		assertEquals("Not a field declaration", ASTNode.FIELD_DECLARATION, node.getNodeType());		
		FieldDeclaration field = (FieldDeclaration) node;
		type = field.getType();
		assertTrue(type.isQualifiedType());
		QualifiedType qualifiedType = (QualifiedType) type;
		nameQualifiedType = (NameQualifiedType)qualifiedType.getQualifier();
		checkSourceRange(nameQualifiedType, "test404489.bug.@NonNull X", source);
		typeBinding = nameQualifiedType.resolveBinding();
		assertNotNull("null binding", typeBinding);
		assertEquals("not a valid binding", "test404489.bug.X", typeBinding.getQualifiedName());
		name = nameQualifiedType.getName();
		assertSame("bindings different for name qualified type and assocated name", typeBinding, name.resolveTypeBinding());
		
		// qualifier of the name qualified type
		name = nameQualifiedType.getQualifier();
		assertTrue(name.isQualifiedName());
		qualifiedName = (QualifiedName) name;
		checkSourceRange(qualifiedName, "test404489.bug", source);
		typeBinding = qualifiedName.resolveTypeBinding();
		assertNull(typeBinding);
		binding = qualifiedName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489.bug", binding.toString());
		name = qualifiedName.getQualifier();
		assertTrue("wrong name type", name.isSimpleName());
		simpleName = (SimpleName) name;
		checkSourceRange(simpleName, "test404489", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNull(typeBinding);
		binding = simpleName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489", binding.toString());
		simpleName = qualifiedName.getName();
		checkSourceRange(simpleName, "bug", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNull(typeBinding);
		binding = simpleName.resolveBinding();
		assertTrue("not a package binding", binding.getKind() == IBinding.PACKAGE);
		assertEquals("wrong package binding", "package test404489.bug", binding.toString());
		
		// annotations of name qualified type
		annotations = nameQualifiedType.annotations();
		assertTrue(annotations.size() == 1);
		annotation = (Annotation) annotations.get(0);
		typeBinding = annotation.resolveTypeBinding();
		assertNotNull("null binding", typeBinding);
		assertEquals("not a valid binding", "test404489.bug.X.NonNull", typeBinding.getQualifiedName());
		annotationBinding = annotation.resolveAnnotationBinding();
		assertEquals("not a valid annotation binding", "@NonNull()", annotationBinding.toString());
		name = annotation.getTypeName();
		assertTrue(name.isSimpleName());
		simpleName = (SimpleName) name;
		typeBinding = simpleName.resolveTypeBinding();
		checkSourceRange(simpleName, "NonNull", source);
		assertNotNull(typeBinding);
		
		// name of the name qualified type
		simpleName = nameQualifiedType.getName();
		checkSourceRange(simpleName, "X", source);
		typeBinding = simpleName.resolveTypeBinding();
		assertNotNull(typeBinding);
		
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=399792
	public void testBug399792() throws JavaModelException {
		String content =
				"import java.lang.annotation.ElementType;\n" +
				"import java.io.Serializable;\n" +
				"public class X {\n" +
				"      Object o = (@Marker1 @Marker2 Serializable & I & @Marker3 @Marker1 J) () -> {};" +
				"      public Serializable main(Object o) {\n" +
				"    	  Serializable oo = (Serializable & @Marker3 @Marker1 @Marker2 I & J) o;\n" +
				"    	  return oo;\n" +
				"      }\n" +
				"}\n" +
				"interface I {\n" +
				"  public void foo();\n" +
				"}\n" +
				"interface J {\n" +
				"  public void foo();\n" +
				"  public void bar();\n" +
				"}\n" +
				"interface K {\n" +
				"  public void foo();\n" +
				"  public void bar();\n" +
				"}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" +
				"@interface Marker {}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" +
				"@interface Marker2 {}\n" +
				"@java.lang.annotation.Target (ElementType.TYPE_USE)\n" +
				"@interface Marker3 {}";

		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", false);
		ASTNode node = buildAST(content, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		TypeDeclaration type =  (TypeDeclaration) unit.types().get(0);
		node = (ASTNode) type.bodyDeclarations().get(0);
		assertEquals("Not a field Declaration", ASTNode.FIELD_DECLARATION, node.getNodeType());
		FieldDeclaration field = (FieldDeclaration) node;
		assertEquals("Field should not be malformed", 0, (field.getFlags() & ASTNode.MALFORMED));

		List fragments = field.fragments();
		assertEquals("Incorrect no of fragments", 1, fragments.size());
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0);
		CastExpression cast = (CastExpression) fragment.getInitializer();
		Type castType = cast.getType();
		assertEquals("Not an intersection cast type", ASTNode.INTERSECTION_TYPE, castType.getNodeType());
		assertTrue("Not an intersection cast type", castType.isIntersectionType());
		assertEquals("Type should not be malformed", 0, (castType.getFlags() & ASTNode.MALFORMED));

		List intersectionTypes = ((IntersectionType) castType).types();
		assertEquals("Incorrect no of types", 3, intersectionTypes.size());
		castType = (Type) intersectionTypes.get(0);
		assertEquals("Incorrect type", ASTNode.SIMPLE_TYPE, castType.getNodeType());
		SimpleName name = (SimpleName) ((SimpleType) castType).getName();
		assertEquals("Incorrect name", "Serializable", name.getIdentifier());

		List annotations = ((SimpleType) castType).annotations();
		assertEquals("Incorrect no of annotations", 2, annotations.size());
		assertEquals("Incorrect receiver", "@Marker1 @Marker2 Serializable", castType.toString());

		castType = (Type) intersectionTypes.get(1);
		assertEquals("Incorrect type", ASTNode.SIMPLE_TYPE, castType.getNodeType());
		name = (SimpleName) ((SimpleType) castType).getName();
		assertEquals("Incorrect name", "I", name.getIdentifier());

		annotations = ((SimpleType) castType).annotations();
		assertEquals("Incorrect no of annotations", 0, annotations.size());
		assertEquals("Incorrect receiver", "I", castType.toString());

		castType = (Type) intersectionTypes.get(2);
		assertEquals("Incorrect type", ASTNode.SIMPLE_TYPE, castType.getNodeType());
		name = (SimpleName) ((SimpleType) castType).getName();
		assertEquals("Incorrect name", "J", name.getIdentifier());

		annotations = ((SimpleType) castType).annotations();
		assertEquals("Incorrect no of annotations", 2, annotations.size());
		assertEquals("Incorrect receiver", "@Marker3 @Marker1 J", castType.toString());

		node = (ASTNode) type.bodyDeclarations().get(1);
		assertEquals("Not a method Declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		MethodDeclaration method = (MethodDeclaration) node;
		assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED));
		
		List statements = method.getBody().statements();
		VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(0);
		fragment = (VariableDeclarationFragment) statement.fragments().get(0);
		cast = (CastExpression) fragment.getInitializer();
		castType = cast.getType();
		
		intersectionTypes = ((IntersectionType) castType).types();
		assertEquals("Incorrect no of types", 3, intersectionTypes.size());
		castType = (Type) intersectionTypes.get(0);

		annotations = ((SimpleType) castType).annotations();
		assertEquals("Incorrect no of annotations", 0, annotations.size());
		assertEquals("Incorrect receiver", "Serializable", castType.toString());

		castType = (Type) intersectionTypes.get(1);
		annotations = ((SimpleType) castType).annotations();
		assertEquals("Incorrect no of annotations", 3, annotations.size());
		assertEquals("Incorrect receiver", "@Marker3 @Marker1 @Marker2 I", castType.toString());

		castType = (Type) intersectionTypes.get(2);

		annotations = ((SimpleType) castType).annotations();
		assertEquals("Incorrect no of annotations", 0, annotations.size());
		assertEquals("Incorrect receiver", "J", castType.toString());
	}
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=406505
	 * tests the source range issue that resulted in bad ast node.
	 * 
	 * @throws JavaModelException
	 */
	public void testBug406505() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test406505/X.java",
				true/* resolve */);
		String contents = "package test406505;"
				+ "import java.lang.annotation.Target;\n"
				+ "import java.io.File;\n"
				+ "public class X {\n"
				+ "	class Folder<@Marker  F extends File> { }\n"
				+ "}\n" 		
				+ "@Target (java.lang.annotation.ElementType.TYPE_USE)\n"
				+ "@interface Marker {}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);		
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 0);
		typedeclaration = (TypeDeclaration)typedeclaration.bodyDeclarations().get(0);
		TypeParameter typeParameter = (TypeParameter) typedeclaration.typeParameters().get(0);
		checkSourceRange(typeParameter, "@Marker  F extends File", contents);
	}

	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=412726
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=428526
	public void testBug412726() throws JavaModelException {
		String contents =
			"public interface X {\n" +
			"	abstract void foo();\n" +
			"}\n" +
			"interface Y1 {\n" +
			"}\n" +
			"interface Y2 {\n" +
			"	default void foo() {}\n" +
			"}\n" +
			"interface Z1 {\n" +
			"	default void foo(){}\n" +
			"	abstract void bar();\n" +
			"}\n" +
			"interface Z2 {\n" +
			"	default void foo(){}\n" +
			"	abstract void bar1();\n" +
			"	abstract void bar2();\n" +
			"}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy, true);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		/* case 0: vanilla case - interface with one abstract method */
		TypeDeclaration type =  (TypeDeclaration) unit.types().get(0);
		ITypeBinding typeBinding = type.resolveBinding();
		assertEquals("Incorrect method", typeBinding.getDeclaredMethods()[0], typeBinding.getFunctionalInterfaceMethod());
		/* case 1: interface without any method */
		type =  (TypeDeclaration) unit.types().get(1);
		typeBinding = type.resolveBinding();
		assertNull(typeBinding.getFunctionalInterfaceMethod());
		/* case 2: interface with just one default method and without any abstract method */
		type =  (TypeDeclaration) unit.types().get(2);
		typeBinding = type.resolveBinding();
		assertNull(typeBinding.getFunctionalInterfaceMethod());
		/* case 3: interface with just one default method and one abstract method */
		type =  (TypeDeclaration) unit.types().get(3);
		typeBinding = type.resolveBinding();
		IMethodBinding functionalInterfaceMethod = typeBinding.getFunctionalInterfaceMethod();
		assertNotNull(functionalInterfaceMethod);
		assertEquals("Incorrect method", "public abstract void bar() ", functionalInterfaceMethod.toString());
		assertEquals(typeBinding, functionalInterfaceMethod.getDeclaringClass());
		/* case 4: interface with just one default method and two abstract methods */
		type =  (TypeDeclaration) unit.types().get(4);
		typeBinding = type.resolveBinding();
		assertNull(typeBinding.getFunctionalInterfaceMethod());
	}
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017
	 * 
	 * @throws JavaModelException
	 */
	public void test417017a() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test417017/X.java",
				true/* resolve */);
		String contents = "package test417017;"
				+ "interface I {\n"
				+ "	int foo(int x);\n"
				+ "}\n" 
				+ "public class X {\n"
				+ " void fun(int a) {\n"
				+"  	I i1 = x1-> x1;\n"
				+"  	I i2 = xxx-> {\n"
				+"  		i1.foo(a);\n"
				+"  		return xxx;\n"
				+"  	};\n"
				+"  }\n"
				+"}\n";
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1);
		MethodDeclaration methodDeclaration = typedeclaration.getMethods()[0];
		VariableDeclarationFragment vdf= (VariableDeclarationFragment) ((VariableDeclarationStatement) methodDeclaration.getBody().statements().get(1)).fragments().get(0);
		LambdaExpression lambda= (LambdaExpression) vdf.getInitializer();
		List parameters = lambda.parameters();
		assertTrue("Incorrect Number of parameters", parameters.size() == 1);
		ITypeBinding[] parameterTypes= lambda.resolveMethodBinding().getParameterTypes();
		assertTrue("Incorrect Number of parameter type", parameterTypes.length == 1);
		assertEquals("Incorrect parameter type", "int", parameterTypes[0].toString());
	}
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017
	 * 
	 * @throws JavaModelException
	 */
	public void test417017b() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test417017/X.java",
				true/* resolve */);
		String contents = "package test417017;" +
				"interface I1 {\n" +
				"	int foo(int a);\n" +
				"}\n" +
				"\n" +
				"interface I2 {\n" +
				"	public default int foo() {\n" +
				"		I1 i1 = (a) -> {\n" +
				"			return a;\n" +
				"		};\n" +
				"		//return 0;\n" + // Error on purpose
				"	}\n" +
				"}\n" ;
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy, false);
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1);
		MethodDeclaration methodDeclaration = typedeclaration.getMethods()[0];
		VariableDeclarationFragment vdf= (VariableDeclarationFragment) ((VariableDeclarationStatement) methodDeclaration.getBody().statements().get(0)).fragments().get(0);
		LambdaExpression lambda= (LambdaExpression) vdf.getInitializer();
		List parameters = lambda.parameters();
		assertTrue("Incorrect Number of parameters", parameters.size() == 1);
		ITypeBinding[] parameterTypes= lambda.resolveMethodBinding().getParameterTypes();
		assertTrue("Incorrect Number of parameter type", parameterTypes.length == 1);
		assertEquals("Incorrect parameter type", "int", parameterTypes[0].toString());
	}
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017
	 * 
	 * @throws JavaModelException
	 */
	public void test417017c() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test417017/X.java",
				true/* resolve */);
		String contents = "package test417017;" +
				"interface I1 {\n" +
				"	int foo(int a);\n" +
				"}\n" +
				"\n" +
				"interface I2 {\n" +
				"	public default int foo() {\n" +
				"		I1 i1 = (float a) -> {\n" +
				"			return a;\n" +
				"		};\n" +
				"		//return 0;\n" + // Error on purpose
				"	}\n" +
				"}\n" ;
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy, false);
		TypeDeclaration typedeclaration = (TypeDeclaration) getASTNode(cu, 1);
		MethodDeclaration methodDeclaration = typedeclaration.getMethods()[0];
		VariableDeclarationFragment vdf= (VariableDeclarationFragment) ((VariableDeclarationStatement) methodDeclaration.getBody().statements().get(0)).fragments().get(0);
		LambdaExpression lambda= (LambdaExpression) vdf.getInitializer();
		List parameters = lambda.parameters();
		assertTrue("Incorrect Number of parameters", parameters.size() == 1);
		ITypeBinding[] parameterTypes= lambda.resolveMethodBinding().getParameterTypes();
		assertTrue("Incorrect Number of parameter type", parameterTypes.length == 1);
		assertEquals("Incorrect parameter type", "float", parameterTypes[0].toString());
	}
	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017
	 * 
	 * @throws JavaModelException
	 */
	public void test417017d() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test399794/X.java",
				true/* resolve */);
		String contents = "package test399794;" +
				"interface I {\n" +
				"	void foo(X x);\n" +
				"}\n" +
				"public class X {\n" +
				"	void foo(X x) {\n" +
				"	}\n" +
				"	I i = this::foo;\n" +
				"}\n";
			
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typeDeclaration = (TypeDeclaration) getASTNode(cu, 1);
		FieldDeclaration field = typeDeclaration.getFields()[0];
		
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0);
		Expression expression = fragment.getInitializer();
		ExpressionMethodReference methodReference = (ExpressionMethodReference) expression;
		IMethodBinding methodBinding = methodReference.resolveMethodBinding();
		assertNotNull(methodBinding);
		ITypeBinding [] parameterTypes = methodBinding.getParameterTypes();
		assertTrue("Incorrect Number of parameter type", parameterTypes.length == 1);
		assertEquals("Incorrect parameter type", "X", parameterTypes[0].getName());
	}

	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017
	 * 
	 * @throws JavaModelException
	 */
	public void test417017e() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test399794/X.java",
				true/* resolve */);
		String contents = "package test399794;" +
				"interface I {\n" +
				"	int [] foo(int x);\n" +
				"}\n" +
				"public class X {\n" +
				"	I i = int []::new;\n" +
				"}\n";
			
		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typeDeclaration = (TypeDeclaration) getASTNode(cu, 1);
		FieldDeclaration field = typeDeclaration.getFields()[0];

		VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0);
		Expression expression = fragment.getInitializer();
		CreationReference creationReference = (CreationReference) expression;
		IMethodBinding methodBinding = creationReference.resolveMethodBinding();
		assertNotNull(methodBinding);
		assertEquals("Wrong name", "lambda$0", methodBinding.getName());
		ITypeBinding [] parameterTypes = methodBinding.getParameterTypes();
		assertTrue("Incorrect Number of parameter type", parameterTypes.length == 1);
		assertEquals("Incorrect parameter type", "int", parameterTypes[0].getName());
	}

	/**
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=417017
	 * 
	 * @throws JavaModelException
	 */
	public void test417017f() throws JavaModelException {
		this.workingCopy = getWorkingCopy("/Converter18/src/test399794/X.java",
				true/* resolve */);
		String contents = "package test399794;" +
				"interface I {\n" +
				"	void foo(X x);\n" +
				"}\n" +
				"public class X {\n" +
				"	private void foo(X x) {\n" +
				"	}\n" +
				"	class Y {\n" +
				"		I i = X.this::foo;\n" +
				"	}\n" +
				"}\n";

		CompilationUnit cu = (CompilationUnit) buildAST(contents, this.workingCopy);
		TypeDeclaration typeDeclaration = (TypeDeclaration) getASTNode(cu, 1);
		typeDeclaration = typeDeclaration.getTypes()[0];
		FieldDeclaration field = typeDeclaration.getFields()[0];

		VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0);
		Expression expression = fragment.getInitializer();
		ExpressionMethodReference reference = (ExpressionMethodReference) expression;
		IMethodBinding methodBinding = reference.resolveMethodBinding();
		assertNotNull(methodBinding);
		assertEquals("Wrong name", "foo", methodBinding.getName());
		ITypeBinding [] parameterTypes = methodBinding.getParameterTypes();
		assertTrue("Incorrect Number of parameter type", parameterTypes.length == 1);
		assertEquals("Incorrect parameter type", "X", parameterTypes[0].getName());
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=413942
	// also refer https://bugs.eclipse.org/bugs/show_bug.cgi?id=413569
	public void testBug413942() throws JavaModelException {
		String contents =
		"public class X extends @NonNull(int[].class) Object {\n" +
		"    Object field = new ArrayList< @NonEmpty(0) int @NonNull(value1 = 1) [] @NonEmpty(1) [ ]>() ;\n" +
		"    @Annot int @Annot1 [] a1 @Annot2 @Annot3 @NonNull (value = int[].class, value1 = 0)[/* [] */ ] @Annot3 @Annot2 [] @Annot4 [];\n" +
		"    int[] xxx[];\n" +
		"    int [][] ii = new int[2][3];" +
		"    ArrayList<int[]> [][] yyy; // source ranges already broken in AST.JLS4\n" +
		"    ArrayList<int[][]> [][][][] zzz;\n" +
		"    ArrayList<Float> [][][] zzz2;\n" +
		"    Object a = new ArrayList< @TakeType(int[][].class) int @TakeType(float.class) [] @TakeType(double.class) []>() ;\n" +
		"    Object b = new @NonNull(value1 = Math.PI) ArrayList< >() ; \n" +
		"    Object c = new ArrayList<@NonNull(value1= Math.PI ) Object[]>() ;\n" +
		"\n" +
		"    int foo(@TakeType(int[].class)int i ) @TakeType(int[].class) [] {\n" +
		"        int[] arr =  new int[2];\n" +
		"        for (String tab @TakeType(int[].class) [] = null;; ++i) { break; }\n" +
		"        for (@Deprecated String tab@TakeType(int[].class) [][]  = null;; ++i) {}\n" +
		"    }\n" +
		"    int bar(int [] /*@TakeType(int[].class)*/ [] a ) {\n" +
		"    	return 0;\n" +
		"    }\n" +
		"public int var1(int @TakeType(int[].class)... args) { return 0;}\n" +
		"public int var2(int @Annot ... args) { return 0;}\n" +
		"}\n" +
		"\n" +
		"@Target(ElementType.TYPE_USE)\n" +
		"@Retention(RetentionPolicy.RUNTIME)\n" +
		"@Documented\n" +
		"@interface NonNull {\n" +
		"	Class value() default int.class;\n" +
		"	double value1() default 0;\n" +
		"}\n" +
		"\n" +
		"@Target(ElementType.TYPE_USE)\n" +
		"@Retention(RetentionPolicy.RUNTIME)\n" +
		"@Documented\n" +
		"@interface NonEmpty {\n" +
		"	int value() default 0;\n" +
		"}\n" +
		"\n" +
		"@Target(ElementType.TYPE_USE)\n" +
		"@Retention(RetentionPolicy.RUNTIME)\n" +
		"@Documented\n" +
		"@interface TakeType {\n" +
		"	Class value() default int[].class;\n" +
		"}\n" +
		"\n" +
		"@Target(ElementType.TYPE_USE)\n" +
		"@Retention(RetentionPolicy.RUNTIME)\n" +
		"@Documented\n" +
		"@interface Annot {}\n" +
		"\n" +
		"@Target(ElementType.TYPE_USE)\n" +
		"@Retention(RetentionPolicy.RUNTIME)\n" +
		"@Documented\n" +
		"@interface Annot1 {}\n" +
		"\n" +
		"@Target(ElementType.TYPE_USE)\n" +
		"@Retention(RetentionPolicy.RUNTIME)\n" +
		"@Documented\n" +
		"@interface Annot2 {}\n" +
		"\n" +
		"@Target(ElementType.TYPE_USE)\n" +
		"@Retention(RetentionPolicy.RUNTIME)\n" +
		"@Documented\n" +
		"@interface Annot3 {}\n" +
		"\n" +
		"@Target(ElementType.TYPE_USE)\n" +
		"@Retention(RetentionPolicy.RUNTIME)\n" +
		"@Documented\n" +
		"@interface Annot4 {}\n" +
		"\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		
		TypeDeclaration type =  (TypeDeclaration) unit.types().get(0);
		SimpleType simpleType =  (SimpleType) type.getSuperclassType();
		checkSourceRange(simpleType, "@NonNull(int[].class) Object", contents);
		SingleMemberAnnotation singleMemberAnnotation = (SingleMemberAnnotation) simpleType.annotations().get(0);
		checkSourceRange(singleMemberAnnotation, "@NonNull(int[].class)", contents);
		TypeLiteral typeLiteral = (TypeLiteral) singleMemberAnnotation.getValue();
		checkSourceRange(typeLiteral, "int[].class", contents);
		ArrayType arrayType = (ArrayType) typeLiteral.getType();
		checkSourceRange(arrayType, "int[]", contents);
		
		int count = 0;
		FieldDeclaration field = (FieldDeclaration) type.bodyDeclarations().get(count++);
		checkSourceRange(field, "Object field = new ArrayList< @NonEmpty(0) int @NonNull(value1 = 1) [] @NonEmpty(1) [ ]>() ;", contents);
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) field.fragments().get(0);
		ClassInstanceCreation instance = (ClassInstanceCreation) fragment.getInitializer();
		ParameterizedType parameterizedType = (ParameterizedType) instance.getType();
		arrayType = (ArrayType) parameterizedType.typeArguments().get(0);
		checkSourceRange(arrayType, "@NonEmpty(0) int @NonNull(value1 = 1) [] @NonEmpty(1) [ ]", contents);
		PrimitiveType primitiveType = (PrimitiveType) arrayType.getElementType();
		checkSourceRange(primitiveType, "@NonEmpty(0) int", contents);
		Dimension dimension = (Dimension) arrayType.dimensions().get(0);
		checkSourceRange(dimension, "@NonNull(value1 = 1) []", contents);
		dimension = (Dimension) arrayType.dimensions().get(1);
		checkSourceRange(dimension, "@NonEmpty(1) [ ]", contents);
		
		field = (FieldDeclaration) type.bodyDeclarations().get(count++);
		checkSourceRange(field, "@Annot int @Annot1 [] a1 @Annot2 @Annot3 @NonNull (value = int[].class, value1 = 0)[/* [] */ ] @Annot3 @Annot2 [] @Annot4 [];", contents);
		arrayType = (ArrayType) field.getType();
		checkSourceRange(arrayType, "int @Annot1 []", contents);
		fragment = (VariableDeclarationFragment) field.fragments().get(0);
		dimension = (Dimension) fragment.extraDimensions().get(0);
		checkSourceRange(dimension, "@Annot2 @Annot3 @NonNull (value = int[].class, value1 = 0)[/* [] */ ]", contents);
		dimension = (Dimension) fragment.extraDimensions().get(1);
		checkSourceRange(dimension, "@Annot3 @Annot2 []", contents);
		
		field = (FieldDeclaration) type.bodyDeclarations().get(count++);
		checkSourceRange(field, "int[] xxx[];", contents);
		assertTrue(field.getType().isArrayType());
		arrayType = (ArrayType) field.getType();
		checkSourceRange(arrayType, "int[]", contents);
		
		field = (FieldDeclaration) type.bodyDeclarations().get(count++);
		checkSourceRange(field, "int [][] ii = new int[2][3];", contents);
		arrayType = (ArrayType) field.getType();
		checkSourceRange(arrayType, "int [][]", contents);
		fragment = (VariableDeclarationFragment) field.fragments().get(0);
		ArrayCreation arrayCreation = (ArrayCreation) fragment.getInitializer();
		arrayType = arrayCreation.getType();
		assertTrue(arrayType.getElementType().isPrimitiveType());
		assertTrue(arrayType.getDimensions() == 2);
		
		field = (FieldDeclaration) type.bodyDeclarations().get(count++);
		checkSourceRange(field, "ArrayList<int[]> [][] yyy;", contents);
		arrayType = (ArrayType) field.getType();
		checkSourceRange(arrayType, "ArrayList<int[]> [][]", contents);

		field = (FieldDeclaration) type.bodyDeclarations().get(count++);
		checkSourceRange(field, "ArrayList<int[][]> [][][][] zzz;", contents);
		arrayType = (ArrayType) field.getType();
		assertTrue(arrayType.getElementType().isParameterizedType());
		assertTrue(arrayType.getDimensions() == 4);
		
		field = (FieldDeclaration) type.bodyDeclarations().get(count++);
		checkSourceRange(field, "ArrayList<Float> [][][] zzz2;", contents);
		arrayType = (ArrayType) field.getType();
		assertTrue(arrayType.getElementType().isParameterizedType());
		assertTrue(arrayType.getDimensions() == 3);
		
		field = (FieldDeclaration) type.bodyDeclarations().get(count++);
		checkSourceRange(field, "Object a = new ArrayList< @TakeType(int[][].class) int @TakeType(float.class) [] @TakeType(double.class) []>() ;", contents);
		fragment = (VariableDeclarationFragment) field.fragments().get(0);
		ClassInstanceCreation classInstanceCreation = (ClassInstanceCreation) fragment.getInitializer();
		parameterizedType = (ParameterizedType) classInstanceCreation.getType();
		arrayType = (ArrayType) parameterizedType.typeArguments().get(0);
		checkSourceRange(arrayType, "@TakeType(int[][].class) int @TakeType(float.class) [] @TakeType(double.class) []", contents);
		checkSourceRange(arrayType.getElementType(), "@TakeType(int[][].class) int", contents);
		assertTrue(arrayType.getElementType().isPrimitiveType());
		dimension = (Dimension) arrayType.dimensions().get(0);
		checkSourceRange(dimension, "@TakeType(float.class) []", contents);
		dimension = (Dimension) arrayType.dimensions().get(1);
		Annotation annotation = (Annotation) dimension.annotations().get(0);
		assertTrue(annotation.isSingleMemberAnnotation());
		singleMemberAnnotation = (SingleMemberAnnotation) annotation;
		typeLiteral = (TypeLiteral) singleMemberAnnotation.getValue();
		checkSourceRange(typeLiteral, "double.class", contents);
		
		field = (FieldDeclaration) type.bodyDeclarations().get(count++);
		checkSourceRange(field, "Object b = new @NonNull(value1 = Math.PI) ArrayList< >() ;", contents);
		fragment = (VariableDeclarationFragment) field.fragments().get(0);
		classInstanceCreation = (ClassInstanceCreation) fragment.getInitializer();
		parameterizedType = (ParameterizedType) classInstanceCreation.getType();
		checkSourceRange(parameterizedType.getType(), "@NonNull(value1 = Math.PI) ArrayList", contents);
		
		field = (FieldDeclaration) type.bodyDeclarations().get(count++);
		checkSourceRange(field, "Object c = new ArrayList<@NonNull(value1= Math.PI ) Object[]>() ;", contents);
		fragment = (VariableDeclarationFragment) field.fragments().get(0);
		classInstanceCreation = (ClassInstanceCreation) fragment.getInitializer();
		parameterizedType = (ParameterizedType) classInstanceCreation.getType();
		arrayType = (ArrayType) parameterizedType.typeArguments().get(0);
		assertTrue(arrayType.getDimensions() == 1);
		
		MethodDeclaration method = (MethodDeclaration) type.bodyDeclarations().get(count++);
		dimension = (Dimension) method.extraDimensions().get(0);
		checkSourceRange(dimension, "@TakeType(int[].class) []", contents);
		singleMemberAnnotation = (SingleMemberAnnotation) dimension.annotations().get(0);
		typeLiteral = (TypeLiteral) singleMemberAnnotation.getValue();
		arrayType = (ArrayType) typeLiteral.getType();
		assertTrue(arrayType.getElementType().isPrimitiveType());
		assertTrue(arrayType.getDimensions() == 1);
		SingleVariableDeclaration singleVariableDeclaration = (SingleVariableDeclaration) method.parameters().get(0);
		singleMemberAnnotation = (SingleMemberAnnotation) singleVariableDeclaration.modifiers().get(0);
		checkSourceRange(singleMemberAnnotation, "@TakeType(int[].class)", contents);
		typeLiteral = (TypeLiteral) singleMemberAnnotation.getValue();
		arrayType = (ArrayType) typeLiteral.getType();
		assertTrue(arrayType.getElementType().isPrimitiveType());
		assertTrue(arrayType.getDimensions() == 1);
		ForStatement forStatement = (ForStatement) method.getBody().statements().get(1);
		VariableDeclarationExpression variableDeclarationExpression = (VariableDeclarationExpression) forStatement.initializers().get(0);
		fragment = (VariableDeclarationFragment) variableDeclarationExpression.fragments().get(0);
		dimension = (Dimension) fragment.extraDimensions().get(0);
		checkSourceRange(dimension, "@TakeType(int[].class) []", contents);
		forStatement = (ForStatement) method.getBody().statements().get(1);
		variableDeclarationExpression = (VariableDeclarationExpression) forStatement.initializers().get(0);
		fragment = (VariableDeclarationFragment) variableDeclarationExpression.fragments().get(0);
		dimension = (Dimension) fragment.extraDimensions().get(0);
		checkSourceRange(dimension, "@TakeType(int[].class) []", contents);
		
		method = (MethodDeclaration) type.bodyDeclarations().get(count++);
		singleVariableDeclaration = (SingleVariableDeclaration) method.parameters().get(0);
		// test case active only after bug 417660 is fixed (uncomment)
		checkSourceRange(singleVariableDeclaration, "int [] /*@TakeType(int[].class)*/ [] a", contents);
		
		method = (MethodDeclaration) type.bodyDeclarations().get(count++);
		singleVariableDeclaration = (SingleVariableDeclaration) method.parameters().get(0);
		checkSourceRange(singleVariableDeclaration, "int @TakeType(int[].class)... args", contents);
		singleMemberAnnotation = (SingleMemberAnnotation) singleVariableDeclaration.varargsAnnotations().get(0);
		typeLiteral = (TypeLiteral) singleMemberAnnotation.getValue();
		arrayType = (ArrayType) typeLiteral.getType();
		assertTrue(arrayType.getElementType().isPrimitiveType());
		assertTrue(arrayType.getDimensions() == 1);
		
		method = (MethodDeclaration) type.bodyDeclarations().get(count++);
		singleVariableDeclaration = (SingleVariableDeclaration) method.parameters().get(0);
		checkSourceRange(singleVariableDeclaration, "int @Annot ... args", contents);
		assertTrue(singleVariableDeclaration.varargsAnnotations().size() == 1);

	}
	// 	https://bugs.eclipse.org/bugs/show_bug.cgi?id=409586
	public void testBug409586() throws JavaModelException {
		String contents = 
				"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
				"@interface Marker {\n" +
				" 	String value() default \"\";\n" +
				"}\n" +
				"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
				"@interface Marker2 {\n" +
				" 	String value() default \"22\";\n" +
				"}\n" +
				"public class X {\n" +
				"	public @Marker(\"1\") String foo(int @Marker @Marker2 [] args) {\n" +
				"      return null;\n" +
				"	}\n" +
				"	public @Marker(\"3\") String bar() {\n" +
				"      return null;\n" +
				"	}\n" +
				"   public String @Marker(\"i0\") @Marker2 [] [] @Marker(\"i1\") [] str = null;\n" +
				"   public @Marker String str2 = null;\n" +
				"   public @Marker String str3 = null;\n" +
				"   public String str4 = null;\n" +
				"}";

		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 2, 0);
		assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION);
		MethodDeclaration methodDeclaration = (MethodDeclaration) node;
		IMethodBinding mBinding = methodDeclaration.resolveBinding();
		assertNotNull("Should not be null", mBinding);
		ITypeBinding tBinding1 = mBinding.getReturnType();
		assertNotNull("Should not be null", tBinding1);
		
		/* public @Marker("1") String foo(int @Marker @Marker2 [] args) */
		List params = methodDeclaration.parameters();
		assertEquals("Incorrect params", 1, params.size());
		SingleVariableDeclaration param = (SingleVariableDeclaration) params.get(0);
		ArrayType type = (ArrayType) param.getType();
		ITypeBinding tBinding = type.resolveBinding();
		assertNotNull("Should not be null", tBinding);
		IAnnotationBinding[] annots = tBinding.getTypeAnnotations();
		assertEquals("Incorrect type annotations", 2, annots.length);
		assertEquals("Incorrect annotation", "@Marker()", annots[0].toString());
		assertEquals("Incorrect annotation", "@Marker2()", annots[1].toString());
		
		/* public @Marker("3") String bar()*/
		node = getASTNode(compilationUnit, 2, 1);
		assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION);
		methodDeclaration = (MethodDeclaration) node;
		mBinding = methodDeclaration.resolveBinding();
		assertNotNull("Should not be null", mBinding);
		ITypeBinding tBinding2 = mBinding.getReturnType();
		assertNotNull("Should not be null", tBinding1);
		assertNotSame("Type bindings should not be same", tBinding1, tBinding2);
		annots = tBinding1.getTypeAnnotations();
		assertEquals("Incorrect type annotations", 1, annots.length);
		IAnnotationBinding annot = annots[0];
		assertEquals("Incorrect annotation", "@Marker(value = 1)", annot.toString());
		annots = tBinding2.getTypeAnnotations();
		assertEquals("Incorrect type annotations", 1, annots.length);
		annot = annots[0];
		assertEquals("Incorrect annotation", "@Marker(value = 3)", annot.toString());

		/* public String @Marker("i0") @Marker2 [] [] @Marker("i1") [] str = null; */
		node = getASTNode(compilationUnit, 2, 2);
		assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION);
		FieldDeclaration field = (FieldDeclaration) node;
		List fragments = field.fragments();
		assertEquals("Incorrect no of fragments", 1, fragments.size());
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0);
		IVariableBinding variable = fragment.resolveBinding();
		assertNotNull("Should not be null", variable);
		ITypeBinding tBinding3 = variable.getType();
		assertNotNull("Should not be null", tBinding3);
		annots = tBinding3.getTypeAnnotations();

		assertEquals("Incorrect type annotations", 2, annots.length);
		assertEquals("Incorrect annotation", "@Marker(value = i0)", annots[0].toString());
		assertEquals("Incorrect annotation", "@Marker2()", annots[1].toString());
		tBinding3 = tBinding3.getComponentType();
		annots = tBinding3.getTypeAnnotations();
		assertEquals("Incorrect type annotations", 0, annots.length);
		tBinding3 = tBinding3.getComponentType();
		annots = tBinding3.getTypeAnnotations();
		assertEquals("Incorrect type annotations", 1, annots.length);
		assertEquals("Incorrect annotation", "@Marker(value = i1)", annots[0].toString());
		
		/* public @Marker String str2 = null; */
		node = getASTNode(compilationUnit, 2, 3);
		assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION);
		field = (FieldDeclaration) node;
		fragments = field.fragments();
		assertEquals("Incorrect no of fragments", 1, fragments.size());
		fragment = (VariableDeclarationFragment) fragments.get(0);
		variable = fragment.resolveBinding();
		assertNotNull("Should not be null", variable);
		tBinding1 = variable.getType();
		
		/* public @Marker String str3 = null; */
		node = getASTNode(compilationUnit, 2, 4);
		assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION);
		field = (FieldDeclaration) node;
		fragments = field.fragments();
		assertEquals("Incorrect no of fragments", 1, fragments.size());
		fragment = (VariableDeclarationFragment) fragments.get(0);
		variable = fragment.resolveBinding();
		assertNotNull("Should not be null", variable);
		tBinding2 = variable.getType();
		assertSame("Type bindings should be same", tBinding1, tBinding2);
		assertTrue("Unannotated bindings should be same", tBinding1.isEqualTo(tBinding2));
		
		/* public String str4 = null; */
		node = getASTNode(compilationUnit, 2, 5);
		assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION);
		field = (FieldDeclaration) node;
		fragments = field.fragments();
		assertEquals("Incorrect no of fragments", 1, fragments.size());
		fragment = (VariableDeclarationFragment) fragments.get(0);
		variable = fragment.resolveBinding();
		assertNotNull("Should not be null", variable);
		tBinding2 = variable.getType();
		assertNotSame("Type bindings should not be same", tBinding1, tBinding2);
		assertTrue("Unannotated bindings should be same", tBinding1.isEqualTo(tBinding2));
	}
	
	public void testExtendedDimensions() throws JavaModelException {
		String contents = 
				"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
				"@interface Marker {\n" +
				" 	String value() default \"\";\n" +
				"}\n" +
				"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
				"@interface Marker2 {\n" +
				" 	String value() default \"22\";\n" +
				"}\n" +
				"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
				"@interface Marker3 {\n" +
				" 	String value() default \"22\";\n" +
				"}\n" +
				"public class X {\n" +
				"	public @Marker(\"1\") String @Marker(\"2\") [] foo(int @Marker @Marker2 [] args @Marker3 []) @Marker3(\"3\") [] {\n" +
				"      return null;\n" +
				"	}\n" +
				"   public String @Marker(\"i0\") @Marker2 [] [] @Marker(\"i1\") [] str @Marker(\"Extended\") [] = null;\n" +
				"}\n";

		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 3, 0);
		assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION);
		MethodDeclaration methodDeclaration = (MethodDeclaration) node;
		Type returnType = methodDeclaration.getReturnType2();
		ITypeBinding tBinding1 = returnType.resolveBinding();
		assertEquals("Unexpected type", tBinding1.toString(), "@Marker((String)\"1\") String @Marker((String)\"2\") []");
		assertEquals("Unexpected type", methodDeclaration.resolveBinding().getReturnType().toString(), "@Marker((String)\"1\") String @Marker3((String)\"3\") [] @Marker((String)\"2\") []");
		
		List params = methodDeclaration.parameters();
		assertEquals("Incorrect params", 1, params.size());
		SingleVariableDeclaration param = (SingleVariableDeclaration) params.get(0);
		ArrayType type = (ArrayType) param.getType();
		ITypeBinding tBinding = type.resolveBinding();
		assertEquals("Unexpected type", tBinding.toString(), "int @Marker @Marker2 []");
		assertEquals("Unexpected type", param.resolveBinding().getType().toString(), "int @Marker3 [] @Marker @Marker2 []");

		// public String @Marker(\"i0\") @Marker2 [] [] @Marker(\"i1\") [] str @Marker(\"Extended\") [] = null;
		node = getASTNode(compilationUnit, 3, 1);
		assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION);
		FieldDeclaration field = (FieldDeclaration) node;
		List fragments = field.fragments();
		assertEquals("Incorrect no of fragments", 1, fragments.size());
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0);
		assertEquals("Unexpected type", fragment.resolveBinding().getType().toString(), "String @Marker((String)\"Extended\") [] @Marker((String)\"i0\") @Marker2 [] [] @Marker((String)\"i1\") []");
		assertEquals("Unexpected type", "String @Marker(\"i0\") @Marker2 [][] @Marker(\"i1\") []", field.getType().toString());
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=417669
	public void testBug417669() throws JavaModelException {
		String contents = 
				"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
				"@interface Marker {}\n" +
				"public class X {\n" +
				"	public static void main(String [] args) {\n" +
				"      W<String> w = (@Marker W<String>) null;\n" +
				"	}\n" +
				"}\n" +
				"class W<T> {}";

		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 1, 0);
		assertTrue("Not a method declaration", node.getNodeType() == ASTNode.METHOD_DECLARATION);
		MethodDeclaration method = (MethodDeclaration) node;
		assertEquals("Method should not be malformed", 0, (method.getFlags() & ASTNode.MALFORMED));
		
		List statements = method.getBody().statements();
		VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(0);
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) statement.fragments().get(0);
		CastExpression cast = (CastExpression) fragment.getInitializer();
		ParameterizedType castType = (ParameterizedType) cast.getType();
		Type type = castType.getType();
		checkSourceRange(castType, "@Marker W<String>", contents);
		checkSourceRange(type, "@Marker W", contents);
	}

	// Bug 414113 - [1.8] Method Binding for default method has abstract modifier instead of default
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=414113
	public void testBug414113() throws JavaModelException {
		String contents =
			"public interface X {\n" +
			"	int i = foo();\n" +
			"	default int foo_default() { return 1;}\n" +
			"	static int foo_static() { return 1;}\n" +
			"}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		TypeDeclaration type =  (TypeDeclaration) unit.types().get(0);
		MethodDeclaration method = (MethodDeclaration) type.bodyDeclarations().get(1);
		IMethodBinding binding =  method.resolveBinding();
		assertTrue("binding is default", (binding.getModifiers() & Modifier.DEFAULT) != 0);
		method = (MethodDeclaration) type.bodyDeclarations().get(2);
		binding =  method.resolveBinding();
		assertTrue("binding is static", (binding.getModifiers() & Modifier.STATIC) != 0);
	}

	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=420660
	 */
	public void testBug420660() throws JavaModelException {
		String contents =
			"package java.lang;\n" +
			"public class X {\n" +
			"		public void foo(int p, int q) {\n" +
			"			final int finalVar = 1; // not effectively final! \n" +
			"			int effectivelyFinalVar = 2;\n" +
			"			int nonFinalVar = 3;\n" +
			"			nonFinalVar = 4; \n" +
			"			q = 0;\n" + 
			"			try (FIS fis = new FIS()) {\n" + 
			"				if (q == 0) { throw new IOError();	} else { throw new IllegalStateException(); }\n" +
	        "			} catch (IOError | IllegalStateException implicitlyFinalExc) {\n" + 
	        "    			// implicitlyFinalExc is not effectively final!	\n" + 
	        "			} catch (Exception effectivelyFinalExc) {	\n" + 
	        "			}\n" + 
			"		}\n" +
			"}\n" +
			"class IOError extends Exception {private static final long serialVersionUID = 1L;}\n" +
			"class IllegalStateException extends Exception {private static final long serialVersionUID = 1L;}\n" +
			"class FIS implements AutoCloseable {\n	public void close() throws Exception {} \n }\n" +
			"interface AutoCloseable { \n void close() throws Exception; \n}";
		this.workingCopy = getWorkingCopy("/Converter18/src/java/lang/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 0);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods();
		assertEquals("Incorrect no of methods", 1, methods.length);
		MethodDeclaration method = methods[0];
		List params = method.parameters();
		assertEquals("Incorrect no of parameters", 2, params.size());
		SingleVariableDeclaration variable = (SingleVariableDeclaration) params.get(0);
		IVariableBinding binding = variable.resolveBinding();
		assertTrue("Should be effectively final", binding.isEffectivelyFinal());
		variable = (SingleVariableDeclaration) params.get(1);
		binding = variable.resolveBinding();
		assertFalse("Should not be effectively final", binding.isEffectivelyFinal());
		
		List statements = method.getBody().statements();
		VariableDeclarationStatement statement = (VariableDeclarationStatement) statements.get(0);
		List fragments = statement.fragments();
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0);
		binding = fragment.resolveBinding();
		assertFalse("Should not be effectively final", binding.isEffectivelyFinal());
		statement = (VariableDeclarationStatement) statements.get(1);
		fragments = statement.fragments();
		fragment = (VariableDeclarationFragment) fragments.get(0);
		binding = fragment.resolveBinding();
		assertTrue("Should be effectively final", binding.isEffectivelyFinal());

		statement = (VariableDeclarationStatement) statements.get(2);
		fragments = statement.fragments();
		fragment = (VariableDeclarationFragment) fragments.get(0);
		binding = fragment.resolveBinding();
		assertFalse("Should not be effectively final", binding.isEffectivelyFinal());
		
		TryStatement tryStmt = (TryStatement) statements.get(5);
		List resources = tryStmt.resources();
		VariableDeclarationExpression resourceExp = (VariableDeclarationExpression) resources.get(0);
		fragment = (VariableDeclarationFragment) resourceExp.fragments().get(0);
		binding = fragment.resolveBinding();
		assertFalse("Should not be effectively final", binding.isEffectivelyFinal());

		List catches = tryStmt.catchClauses();
		CatchClause catchCl = (CatchClause) catches.get(1);
		variable = catchCl.getException();
		binding = variable.resolveBinding();
		assertTrue("Should be effectively final", binding.isEffectivelyFinal());
		catchCl = (CatchClause) catches.get(0);
		variable = catchCl.getException();
		binding = variable.resolveBinding();
		assertFalse("Should not be effectively final", binding.isEffectivelyFinal());
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=420660
	 */
	public void testBug420660a() throws JavaModelException {
		String contents =
			"interface I {\nvoid foo();\n}\n" +
			"interface J {}\n" +
			"public class X {\n" +
			"		void foo(int [] p) {\n" +
			"			for (int is : p) {\n" +
			"				I j = new I () {\n" +
			"					public void foo() {\n" +
			"						System.out.println(is);\n" +
			"					}\n" + 
			"				};\n" + 
	        "			}\n" + 
			"		}\n" +
			"}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 2);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods();
		assertEquals("Incorrect no of methods", 1, methods.length);
		MethodDeclaration method = methods[0];
		List statements = method.getBody().statements();
		EnhancedForStatement stmt = (EnhancedForStatement) statements.get(0);
		SingleVariableDeclaration variable = stmt.getParameter();
		IVariableBinding binding = variable.resolveBinding();
		assertTrue("Should be effectively final", binding.isEffectivelyFinal());
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=423872
	 */
	public void testBug423872() throws JavaModelException {
		String contents =
			"public interface X {\n" +
			"	void foo(Y.Z<?>... events);\n" +
			"}\n" +
			"interface Y<T> {\n" +
			"	public static interface Z<T> {}\n" +
			"}\n";
		try {
			this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/);
			ASTNode node = buildAST(contents, this.workingCopy);
			assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
			CompilationUnit compilationUnit = (CompilationUnit) node;
			assertProblemsSize(compilationUnit, 0);
			node = getASTNode(compilationUnit, 0);
			assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
			MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods();
			assertEquals("Incorrect no of methods", 1, methods.length);
			MethodDeclaration method = methods[0];
			List parameters = method.parameters();
			assertTrue(parameters.size() == 1);
			SingleVariableDeclaration singleVariableDeclaration = (SingleVariableDeclaration) parameters.get(0);
			checkSourceRange(singleVariableDeclaration, "Y.Z<?>... events", contents);
			assertTrue(singleVariableDeclaration.isVarargs());
			Type type = singleVariableDeclaration.getType();
			assertTrue(type.isParameterizedType());
		} catch (IllegalArgumentException e) {
			assertTrue(false);
		}
	}
	
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=424138
	 */
	public void testBug424138_001() throws JavaModelException {
		String contents =
				"package jsr308.myex;\n" +
				"\n" +
				"public class X extends @jsr308.myex.X.Anno Object {\n" +
				"    void foo(@jsr308.myex.X.Anno X this) {}\n" +
				"    Y<@jsr308.myex.X.Anno Object> l;\n" +
				"    int o @jsr308.myex.X.Anno[];\n" +
				"\n" +
				"	 @jsr308.myex.X.Anno X f;\n" +
				"    int @jsr308.myex.X.Anno[] ok;\n" +
				"    @jsr308.myex.X.Anno X g;\n" +
				"	 void bar(@jsr308.myex.X.Anno X ok) {\n" +
				"        @jsr308.myex.X.Anno X l;\n" +
				"    }\n" +
				"    @java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE)\n" +
				"    public @interface Anno {}\n" +
				"}\n" +
				"class Y<T> {}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/jsr308/myex/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 0);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		TypeDeclaration typeDeclaration = (TypeDeclaration) node;
		SimpleType simpleType = (SimpleType) typeDeclaration.getSuperclassType();
		checkSourceRange(simpleType, "@jsr308.myex.X.Anno Object", contents);
		Annotation annotation = (Annotation) simpleType.annotations().get(0);
		checkSourceRange(annotation, "@jsr308.myex.X.Anno", contents);
		MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods();
		assertEquals("Incorrect no of methods", 2, methods.length);
		MethodDeclaration method = methods[0];
		simpleType = (SimpleType) method.getReceiverType();
		checkSourceRange(simpleType, "@jsr308.myex.X.Anno X", contents);
		FieldDeclaration [] fields = typeDeclaration.getFields();
		FieldDeclaration f = fields[0];
		checkSourceRange(f, "Y<@jsr308.myex.X.Anno Object> l;", contents);
		Type type = f.getType();
		assertTrue(type.isParameterizedType());
		ParameterizedType parameterizedType = (ParameterizedType) type;
		checkSourceRange((ASTNode) parameterizedType.typeArguments().get(0), "@jsr308.myex.X.Anno Object", contents);
		f = fields[1];
		checkSourceRange(f, "int o @jsr308.myex.X.Anno[];", contents);
		assertTrue(f.getType().isPrimitiveType());
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) f.fragments().get(0);
		checkSourceRange((ASTNode) fragment.extraDimensions().get(0), "@jsr308.myex.X.Anno[]", contents);
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=424138
	 */
	public void testBug424138_002() throws JavaModelException {
		String contents =
				"package jsr308.myex;\n" +
				"\n" +
				"public class X{\n" +
				"    int o2[];\n" +
				"    int o1 @jsr308.myex.X.Anno[];\n" +
				"    int @jsr308.myex.X.Anno[][] o3 @jsr308.myex.X.Anno[][];\n" +
				"    @java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE)\n" +
				"    public @interface Anno {}\n" +
				"}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/jsr308/myex/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 0);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		TypeDeclaration typeDeclaration = (TypeDeclaration) node;
		FieldDeclaration [] fields = typeDeclaration.getFields();
		FieldDeclaration f = fields[0];
		checkSourceRange(f, "int o2[];", contents);
		f = fields[1];
		checkSourceRange(f, "int o1 @jsr308.myex.X.Anno[];", contents);
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=424138
	 */
	public void testBug424138_003() throws JavaModelException {
		String contents =
				"package jsr308.myex;\n" +
				"\n" +
				"public class X{\n" +
				"	public void foo() {\n" +
				"		for (int i @jsr308.myex.X.Anno[]: new int[10][12]) {\n" +
				"			System.out.println(\"hello\");\n" +
				"		}\n" +
				"	}\n" +
				"   @java.lang.annotation.Target(java.lang.annotation.ElementType.TYPE_USE)\n" +
				"   public @interface Anno {}\n" +
				"}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/jsr308/myex/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 0);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		TypeDeclaration typeDeclaration = (TypeDeclaration) node;
		MethodDeclaration [] methods = typeDeclaration.getMethods();
		EnhancedForStatement statement = (EnhancedForStatement) methods[0].getBody().statements().get(0);
		SingleVariableDeclaration variable = statement.getParameter();
		checkSourceRange(variable, "int i @jsr308.myex.X.Anno[]", contents);
		Dimension dim = (Dimension) variable.extraDimensions().get(0);
		checkSourceRange(dim, "@jsr308.myex.X.Anno[]", contents);
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=423584, [1.8][dom ast] NPE in LambdaExpression#getMethodBinding() for lambda with unresolved type
	 */
	public void test423584() throws JavaModelException {
		String contents =
				"interface I { }\n" +
				"public class X {\n" +
				"    static void goo(I i) {\n" +
				"        System.out.println(\"goo(I)\");\n" +
				"    }\n" +
				"    public static void main(String[] args) {\n" +
				"        goo(s -> 0);\n" +
				"    }\n" +
				"}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 2, "The method goo(I) in the type X is not applicable for the arguments ((<no type> s) -> 0)\n" + 
												"The target type of this expression must be a functional interface");
		node = getASTNode(compilationUnit, 1);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods();
		assertEquals("Incorrect no of methods", 2, methods.length);
		MethodDeclaration method = methods[1];
		List statements = method.getBody().statements();
		LambdaExpression lambda = (LambdaExpression) ((MethodInvocation) ((ExpressionStatement) statements.get(0)).getExpression()).arguments().get(0);
		IMethodBinding resolveMethodBinding = lambda.resolveMethodBinding();
		assertTrue("Should be null", resolveMethodBinding == null); // no NPE, just a null method binding.
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=418979
	 */
	public void testBug418979_001() throws JavaModelException {
		String contents =
				"import java.lang.annotation.*;\n" +
				"public class X {\n" +
				"    void foo(Y.@A Z<?> events) {}\n" +
				"    void foo(Y.@A ZZ events) {}\n" +
				" }\n" +
				"class Y {\n" +
				"	class Z<T> {}\n" +
				"   class ZZ{}\n" +
				"}\n" +
				"@Target (ElementType.TYPE_USE)\n" +
				"@interface A{}";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 0);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods();
		assertEquals("Incorrect no of methods", 2, methods.length);
		MethodDeclaration method = methods[0];
		List params = method.parameters();
		assertEquals("Incorrect no of parameters", 1, params.size());
		SingleVariableDeclaration variable = (SingleVariableDeclaration) params.get(0);
		Type type = variable.getType();
		assertTrue(type.isParameterizedType());
		ParameterizedType parameterizedType = (ParameterizedType) type;
		checkSourceRange(parameterizedType, "Y.@A Z<?>", contents);
		type = parameterizedType.getType();
		assertTrue(type.isNameQualifiedType());
		NameQualifiedType nameQualifiedType = (NameQualifiedType) type;
		checkSourceRange(nameQualifiedType, "Y.@A Z", contents);

		method = methods[1];
		params = method.parameters();
		assertEquals("Incorrect no of parameters", 1, params.size());
		variable = (SingleVariableDeclaration) params.get(0);
		type = variable.getType();
		assertTrue(type.isNameQualifiedType());
		nameQualifiedType = (NameQualifiedType) type;
		checkSourceRange(nameQualifiedType, "Y.@A ZZ", contents);
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=418979
	 */
	public void testBug418979_002() throws JavaModelException {
		String contents =
				"package test;\n" +
				"import java.lang.annotation.*;\n" +
				"public class X {\n" +
				"    test.@A Outer<C>.@A Inner<C> i;\n" +
				" }\n" +
				"class Outer<T> {\n" +
				"	class Inner<S> {}\n" +
				"}\n" +
				"class C {}\n" +
				"@Target (ElementType.TYPE_USE)\n" +
				"@interface A{}";
		this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		node = getASTNode(compilationUnit, 0);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		FieldDeclaration field = ((TypeDeclaration) node).getFields()[0];
		checkSourceRange(field, "test.@A Outer<C>.@A Inner<C> i;", contents);
		ParameterizedType parameterizedType = (ParameterizedType) field.getType();
		checkSourceRange(parameterizedType, "test.@A Outer<C>.@A Inner<C>", contents);
		QualifiedType qualifiedType = (QualifiedType) parameterizedType.getType();
		checkSourceRange(qualifiedType, "test.@A Outer<C>.@A Inner", contents);
		parameterizedType = (ParameterizedType) qualifiedType.getQualifier();
		checkSourceRange(parameterizedType, "test.@A Outer<C>", contents);
		NameQualifiedType nameQualifiedType = (NameQualifiedType) parameterizedType.getType();
		checkSourceRange(nameQualifiedType, "test.@A Outer", contents);
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=418979
	 */
	public void testBug418979_003() throws JavaModelException {
		String contents =
				"package test;\n" +
				"import java.lang.annotation.*;\n" +
				"public class X {\n" +
				"    public void foo() {\n" +
				"        new java.util.@A HashMap<>();\n" +
				"    }\n" +
				" }\n" +
				"@Target (ElementType.TYPE_USE)\n" +
				"@interface A{}";
		this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		node = getASTNode(compilationUnit, 0);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		MethodDeclaration method = ((TypeDeclaration) node).getMethods()[0];
		ExpressionStatement statement = (ExpressionStatement) method.getBody().statements().get(0);
		ClassInstanceCreation instance = (ClassInstanceCreation) statement.getExpression();
		ParameterizedType parameterizedType = (ParameterizedType) instance.getType();
		checkSourceRange(parameterizedType, "java.util.@A HashMap<>", contents);
		NameQualifiedType nameQualifiedType = (NameQualifiedType) parameterizedType.getType();
		checkSourceRange(nameQualifiedType, "java.util.@A HashMap", contents);
		checkSourceRange(nameQualifiedType.getQualifier(), "java.util", contents);
		checkSourceRange(nameQualifiedType.getName(), "HashMap", contents);
		checkSourceRange((ASTNode) nameQualifiedType.annotations().get(0), "@A", contents);
	}
	/*
	 * [1.8][dom ast] variable binding for LambdaExpression parameter has non-unique key (https://bugs.eclipse.org/bugs/show_bug.cgi?id=416559)
	 */
	public void test416559() throws JavaModelException {
		String contents =
				"interface I {\n" +
				"	int f (int x);\n" +
				"}\n" +
				"\n" +
				"class X {\n" +
				"	I i1 = (x) -> 1;\n" +
				"   I i2 = (x) -> 1;\n" +
				"}\n" ;
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 1);
		FieldDeclaration[] field = ((TypeDeclaration) node).getFields();

		List fragments = field[0].fragments();
		VariableDeclarationFragment fragment = (VariableDeclarationFragment)fragments.get(0);
		Expression expression = fragment.getInitializer();
		LambdaExpression lambdaExpression = (LambdaExpression)expression;
		VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0);
		IVariableBinding variableBinding = variableDeclaration.resolveBinding();
		IMethodBinding methodBinding = lambdaExpression.resolveMethodBinding();
		String methodKey = ((IBinding) methodBinding).getKey();
		String variableKey = ((IBinding) variableBinding).getKey();
		assertTrue(variableKey.regionMatches(0, methodKey, 0, methodKey.length()));

		fragments = field[1].fragments();
		fragment = (VariableDeclarationFragment)fragments.get(0);
		expression = fragment.getInitializer();
		lambdaExpression = (LambdaExpression)expression;
		variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0);
		variableBinding = variableDeclaration.resolveBinding();

		assertNotSame(variableKey.intern(), ((IBinding) variableBinding).getKey().intern());
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=420458
	 */
	public void testBug420458() throws JavaModelException {
		String contents =
				"/**\n" +
				" * Hello\n" +
				" * @see #foo(Object[][][])\n" +
				" **/\n" +
				"public class X {}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		node = getASTNode(compilationUnit, 0);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		Javadoc javaDoc = ((TypeDeclaration) node).getJavadoc();
		TagElement tagElement = (TagElement) javaDoc.tags().get(1);
		MethodRef methodRef = (MethodRef) tagElement.fragments().get(0);
		MethodRefParameter parameter = (MethodRefParameter) methodRef.parameters().get(0);
		ArrayType arrayType = (ArrayType) parameter.getType();
		checkSourceRange(arrayType, "Object[][][]", contents);
		checkSourceRange(arrayType.getElementType(), "Object", contents);
		assertTrue(arrayType.getDimensions() == 3);
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=420458
	 */
	public void testBug425741() throws JavaModelException {
		String contents =
				"@java.lang.annotation.Target (java.lang.annotation.ElementType.TYPE_USE)\n" +
				"@interface Annot { String value(); }\n" +
				"@Annot(\"decl\") public class X {\n" +
				"	@Annot(\"field\") X x = null;\n" +
				"	public void foo(@Annot(\"param\") X i) {\n" +
				"	}\n" +
				"}";
		this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		node = getASTNode(compilationUnit, 1);
		assertEquals("Not a type declaration", ASTNode.TYPE_DECLARATION, node.getNodeType());
		FieldDeclaration field = ((TypeDeclaration) node).getFields()[0];
		List fragments = field.fragments();
		ITypeBinding typeBinding = field.getType().resolveBinding();
		IAnnotationBinding[] annots = typeBinding.getTypeAnnotations();
		assertEquals("Incorrect type annotations", 1, annots.length);
		assertEquals("Incorrect annotation", "@Annot(value = field)", annots[0].toString());
		VariableDeclarationFragment fragment = (VariableDeclarationFragment) fragments.get(0);
		typeBinding = typeBinding.getTypeDeclaration();
		annots = typeBinding.getTypeAnnotations();
		assertEquals("Incorrect type annotations", 0, annots.length);
		typeBinding = fragment.resolveBinding().getType().getTypeDeclaration();
		annots = typeBinding.getTypeAnnotations();
		assertEquals("Incorrect type annotations", 0, annots.length);
		MethodDeclaration method = ((TypeDeclaration) node).getMethods()[0];
		SingleVariableDeclaration param = (SingleVariableDeclaration) method.parameters().get(0);
		typeBinding = param.getType().resolveBinding();
		annots = typeBinding.getTypeAnnotations();
		assertEquals("Incorrect type annotations", 1, annots.length);
		assertEquals("Incorrect annotation", "@Annot(value = param)", annots[0].toString());
		typeBinding = typeBinding.getTypeDeclaration();
		annots = typeBinding.getTypeAnnotations();
		assertEquals("Incorrect type annotations", 0, annots.length);
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=416560, [1.8] Incorrect source range for lambda expression's parameter after reconciliation
	 */
	public void testBug416560_001() throws JavaModelException {
		String contents =
				"import java.lang.annotation.ElementType;\n" +
				"@Target (ElementType.FIELD)\n" +
				"public class X{\n" +
				"    public FI fi= /*a*/(int n1, int n2) -> n1 * n2;\n" +
				"}\n" +
				"public class X\n" +
				"    public FI fi= /*a*/(int n1, int n2) -> n1 * n2;\n" +
				"interface FI {\n" +
				"    int foo(int s1, int s2);\n" +
				"}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/);
		this.workingCopy.getBuffer().setContents(contents);
		CompilationUnit compilationUnit = this.workingCopy.reconcile(AST.JLS8, ICompilationUnit.FORCE_PROBLEM_DETECTION, null, null);
		ASTNode node = getASTNode(compilationUnit, 0);
		FieldDeclaration[] field = ((TypeDeclaration) node).getFields();
		List fragments = field[0].fragments();
		VariableDeclarationFragment fragment = (VariableDeclarationFragment)fragments.get(0);
		Expression expression = fragment.getInitializer();
		LambdaExpression lambdaExpression = (LambdaExpression)expression;
		VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0);
		checkSourceRange(variableDeclaration, "int n1", contents);
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=416560, [1.8] Incorrect source range for lambda expression's parameter after reconciliation
	 */
	public void testBug416560_002() throws JavaModelException {
		String contents =
				"import java.lang.annotation.ElementType;\n" +
				"@Target (ElementType.FIELD)\n" +
				"public class X{\n" +
				"    public FI fi= /*a*/(int n1, int n2) -> n1 * n2;\n" +
				"}\n" +
				"public class X\n" +
				"    public FI fi= /*a*/(int n1, int n2) -> n1 * n2;\n" +
				"interface FI {\n" +
				"    int foo(int s1, int s2);\n" +
				"}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/test/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		node = getASTNode(compilationUnit, 0);
		FieldDeclaration[] field = ((TypeDeclaration) node).getFields();
		List fragments = field[0].fragments();
		VariableDeclarationFragment fragment = (VariableDeclarationFragment)fragments.get(0);
		Expression expression = fragment.getInitializer();
		LambdaExpression lambdaExpression = (LambdaExpression)expression;
		VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0);
		checkSourceRange(variableDeclaration, "int n1", contents);
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=416560, [1.8] Incorrect source range for lambda expression's parameter after reconciliation
	 */
	public void testBug416560_003() throws JavaModelException {
		String contents =
				"public class X{\n" +
				"    void f() {\n" +
				"	    //a\n" +
				"	    //few\n" +
				"	    //comments\n" +
				"	    //here\n" +
				"       bar((int x) -> 91);\n" +
				"	 }\n" +
				"    int bar(FI f){ return 1;}" +
				"}\n" +
				"interface FI {\n" +
				"    int foo(int s1);\n" +
				"}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy, true);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		node = getASTNode(compilationUnit, 0);
		MethodDeclaration[] methods = ((TypeDeclaration) node).getMethods();
		MethodDeclaration method = methods[0];
		Block block = method.getBody();
		List statements = block.statements();
		Statement statement = (Statement) statements.get(0);
		MethodInvocation methodInvocation = (MethodInvocation) ((ExpressionStatement) statement).getExpression();
		LambdaExpression lambdaExpression = (LambdaExpression) methodInvocation.arguments().get(0);
		VariableDeclaration variableDeclaration = (VariableDeclaration) lambdaExpression.parameters().get(0);
		checkSourceRange(variableDeclaration, "int x", contents);
	}
	/*
	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=425743, [1.8][api] CompilationUnit#findDeclaringNode(IBinding binding) returns null for type inferred lambda parameter 
	 */
	public void testBug425743() throws JavaModelException {
		String contents =
				"public class X{\n" +
				"    FI fi = (x2) -> x2;\n" +
				"}\n" +
				"interface FI {\n" +
				"    int foo(int n);\n" +
				"}\n";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true/*resolve*/);
		ASTNode node = buildAST(contents, this.workingCopy, true);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		node = getASTNode(compilationUnit, 0);
		FieldDeclaration fi = ((TypeDeclaration) node).getFields()[0];
		VariableDeclarationFragment vdf = (VariableDeclarationFragment) fi.fragments().get(0);
		LambdaExpression lambda = (LambdaExpression) vdf.getInitializer();
		VariableDeclaration param = (VariableDeclaration) lambda.parameters().get(0);
		IBinding binding = param.getName().resolveBinding();
		ASTNode astNode = compilationUnit.findDeclaringNode(binding);
		assertNotNull(astNode);
		assertEquals("Not a variable declaration fragment", ASTNode.VARIABLE_DECLARATION_FRAGMENT, astNode.getNodeType());
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=427357
	public void testBug427357() throws JavaModelException {
		String contents =
			"public class X {\n" +
			"	public static void foo(X this, int i){}\n" +
			"	public void foo(Inner this){}\n" +
			"	I I = new I() {\n" +
			"		public void bar(I this, int i) {}\n" +
			"	};\n" +
			"	static class Inner {\n" +
			"		public Inner(Test2 Test2.this){}\n" +
			"		public Inner(Inner Inner.this, int i){}\n" + 
			"	}\n" +
			"}\n"+
			"interface I {}";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy, false);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit unit = (CompilationUnit) node;
		TypeDeclaration typeDecl = (TypeDeclaration) unit.types().get(0);
		MethodDeclaration method = (MethodDeclaration) typeDecl.bodyDeclarations().get(0);
		Type receiver = method.getReceiverType();
		assertNotNull("Receiver should not be null", receiver);
		assertEquals("Incorrect receiver type", "X", receiver.toString());
		
		method = (MethodDeclaration) typeDecl.bodyDeclarations().get(1);
		receiver = method.getReceiverType();
		assertNotNull("Receiver should not be null", receiver);

		FieldDeclaration field = (FieldDeclaration) typeDecl.bodyDeclarations().get(2);
		ClassInstanceCreation anonymousInst =  (ClassInstanceCreation ) ((VariableDeclarationFragment) field.fragments().get(0)).getInitializer();
		AnonymousClassDeclaration anonymousDecl = anonymousInst.getAnonymousClassDeclaration();
		method = (MethodDeclaration) anonymousDecl.bodyDeclarations().get(0);
		receiver = method.getReceiverType();
		assertNotNull("Receiver should not be null", receiver);
		assertEquals("Incorrect receiver type", "I", receiver.toString());
		typeDecl = (TypeDeclaration) typeDecl.bodyDeclarations().get(3);
		method = (MethodDeclaration) typeDecl.bodyDeclarations().get(0);
		receiver = method.getReceiverType();
		assertNotNull("Receiver should not be null", receiver);
		assertEquals("Incorrect receiver type", "Test2", receiver.toString());
		method = (MethodDeclaration) typeDecl.bodyDeclarations().get(1);
		receiver = method.getReceiverType();
		assertNotNull("Receiver should not be null", receiver);
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=426459
	public void testBug426459() throws JavaModelException {
		String contents =
			"import java.lang.annotation.*;\n" +
			"@Target(ElementType.TYPE_USE) @interface A {}\n" +
			"@Target(ElementType.TYPE_USE) @interface B {}\n" +
			"@Target(ElementType.TYPE_USE) @interface C {}\n" +
			"public class X {\n" +
			"		@A int @B [] @C [] @A [] is;\n" +
			"		@C String @A [] @B [] @C [] ss;\n" +
			"		@C String @A [] [] [] [] sss;\n" +
			"}";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		node = getASTNode(compilationUnit, 3, 0);
		assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION);
		FieldDeclaration field = (FieldDeclaration) node;
		Type type = field.getType();
		ITypeBinding original = type.resolveBinding();
		assertEquals("Incorrect type binding", "@A int @B [] @C [] @A []", original.toString());
		ITypeBinding binding = original.createArrayType(1);
		assertEquals("Incorrect type binding", "@A int [] @B [] @C [] @A []", binding.toString());
		int dims = binding.getDimensions();
		assertEquals("Incorrect no of dimensions", 4, dims);
		IAnnotationBinding[] annotations = binding.getTypeAnnotations();
		assertEquals("Incorrect no of type annotations", 0, annotations.length);
		binding = binding.getComponentType();
		annotations = binding.getTypeAnnotations();
		assertEquals("Incorrect no of type annotations", 1, annotations.length);
		assertEquals("Incorrect annotation", "@B()", annotations[0].toString());
		binding = binding.getComponentType();
		annotations = binding.getTypeAnnotations();
		assertEquals("Incorrect no of type annotations", 1, annotations.length);
		assertEquals("Incorrect annotation", "@C()", annotations[0].toString());
		binding = binding.getComponentType();
		annotations = binding.getTypeAnnotations();
		assertEquals("Incorrect no of type annotations", 1, annotations.length);
		assertEquals("Incorrect annotation", "@A()", annotations[0].toString());
		binding = binding.getElementType();
		annotations = binding.getTypeAnnotations();
		assertEquals("Incorrect no of type annotations", 1, annotations.length);
		assertEquals("Incorrect annotation", "@A()", annotations[0].toString());
		
		node = getASTNode(compilationUnit, 3, 1);
		assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION);
		field = (FieldDeclaration) node;
		type = field.getType();
		original = type.resolveBinding();
		assertEquals("Incorrect type binding", "@C String @A [] @B [] @C []", original.toString());
		binding = original.createArrayType(1);
		assertEquals("Incorrect type binding", "@C String [] @A [] @B [] @C []", binding.toString());
		dims = binding.getDimensions();
		assertEquals("Incorrect no of dimensions", 4, dims);
		
		binding = original.createArrayType(-1);
		assertEquals("Incorrect type binding", "@C String @B [] @C []", binding.toString());
		dims = binding.getDimensions();
		assertEquals("Incorrect no of dimensions", 2, dims);
		
		binding = original.createArrayType(-2);
		assertEquals("Incorrect type binding", "@C String @C []", binding.toString());
		dims = binding.getDimensions();
		assertEquals("Incorrect no of dimensions", 1, dims);
		
		node = getASTNode(compilationUnit, 3, 2);
		assertTrue("Not a field declaration", node.getNodeType() == ASTNode.FIELD_DECLARATION);
		field = (FieldDeclaration) node;
		type = field.getType();
		original = type.resolveBinding();
		assertEquals("Incorrect type binding", "@C String @A [] [] [] []", original.toString());
		binding = original.createArrayType(-1);
		assertEquals("Incorrect type binding", "@C String [] [] []", binding.toString());
		dims = binding.getDimensions();
		assertEquals("Incorrect no of dimensions", 3, dims);
		binding = binding.createArrayType(-2);
		assertEquals("Incorrect type binding", "@C String []", binding.toString());
		dims = binding.getDimensions();
		assertEquals("Incorrect no of dimensions", 1, dims);
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=426459
	public void testBug426459a() throws JavaModelException {
		String contents =
			"import java.lang.annotation.*;\n" +
			"@Target(ElementType.TYPE_USE) @interface A {}\n" +
			"@Target(ElementType.TYPE_USE) @interface B {}\n" +
			"@Target(ElementType.TYPE_USE) @interface C {}\n" +
			"public class X {\n" +
			"		public void foo() {}\n" +
			"		public @A X.@B Y foo(@C int i){ return null;}\n" +
			"		public @A @B X foo(int i, int j){ return null;}\n" +
			"		public @A X.Y [] @B [] foo(float f){ return null;}\n" +
			"		class Y {}\n" +
			"}";
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		
		node = getASTNode(compilationUnit, 3, 0);
		assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		Type type = ((MethodDeclaration) node).getReturnType2();
		ITypeBinding binding = type.resolveBinding();
		assertNotNull("Binding should not be null", binding);
		try {
			binding = binding.createArrayType(1);
			binding = null;
		} catch(IllegalArgumentException iae) {
		}
		assertNotNull("IllegalArgumentException should have been thrown", binding);

		node = getASTNode(compilationUnit, 3, 1);
		assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		type = ((MethodDeclaration) node).getReturnType2();
		binding = type.resolveBinding();
		assertEquals("Incorrect type binding", "@A X.@B Y", binding.toString());
		binding = binding.createArrayType(2);
		assertEquals("Incorrect type binding", "@A X.@B Y [] []", binding.toString());
		int dims = binding.getDimensions();
		assertEquals("Incorrect no of dimensions", 2, dims);
		SingleVariableDeclaration param = (SingleVariableDeclaration) ((MethodDeclaration) node).parameters().get(0);
		type = param.getType();
		binding = type.resolveBinding();
		assertEquals("Incorrect type binding", "@C int", binding.toString());
		binding = binding.createArrayType(2);
		assertEquals("Incorrect type binding", "@C int [] []", binding.toString());
		
		node = getASTNode(compilationUnit, 3, 2);
		assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		type = ((MethodDeclaration) node).getReturnType2();
		binding = type.resolveBinding();
		assertEquals("Incorrect type binding", "@A @B X", binding.toString());
		binding = binding.createArrayType(2);
		assertEquals("Incorrect type binding", "@A @B X [] []", binding.toString());
		dims = binding.getDimensions();
		assertEquals("Incorrect no of dimensions", 2, dims);
		
		node = getASTNode(compilationUnit, 3, 3);
		assertEquals("Not a method declaration", ASTNode.METHOD_DECLARATION, node.getNodeType());
		type = ((MethodDeclaration) node).getReturnType2();
		ITypeBinding original = type.resolveBinding();
		assertEquals("Incorrect type binding", "@A X.Y [] @B []", original.toString());
		binding = original.createArrayType(1);
		assertEquals("Incorrect type binding", "@A X.Y [] [] @B []", binding.toString());
		dims = binding.getDimensions();
		assertEquals("Incorrect no of dimensions", 3, dims);
		
		binding = original.createArrayType(-1);
		assertEquals("Incorrect type binding", "@A X.Y @B []", binding.toString());
		dims = binding.getDimensions();
		assertEquals("Incorrect no of dimensions", 1, dims);

	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=428526, [1.8] API to get the single abstract method in a functional interface
	public void test428526() throws JavaModelException {
		String contents =
				"interface Foo<T, N extends Number> {\n" +
				"    void m(T arg);\n" +
				"    void m(N arg);\n" +
				"}\n" +
				"interface Baz extends Foo<Integer, Integer> {}\n";
		
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		
		TypeDeclaration type = (TypeDeclaration) getASTNode(compilationUnit, 0);
		assertEquals("Not a Type declaration", ASTNode.TYPE_DECLARATION, type.getNodeType());
		ITypeBinding binding = type.resolveBinding();
		assertNotNull("Binding should not be null", binding);
		IMethodBinding functionalInterfaceMethod = binding.getFunctionalInterfaceMethod();
		assertNull("Should not be a functional interface", functionalInterfaceMethod);
		
		type = (TypeDeclaration) getASTNode(compilationUnit, 1);
		assertEquals("Not a Type declaration", ASTNode.TYPE_DECLARATION, type.getNodeType());
		binding = type.resolveBinding();
		assertNotNull("Binding should not be null", binding);
		functionalInterfaceMethod = binding.getFunctionalInterfaceMethod();
		assertNotNull("Should be a functional interface", functionalInterfaceMethod);
		ITypeBinding declaringClass = functionalInterfaceMethod.getDeclaringClass();
		assertEquals("Foo<Integer,Integer>", declaringClass.getName());
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=428526, [1.8] API to get the single abstract method in a functional interface
	public void test428526a() throws JavaModelException {
		String contents =
				"interface I { X foo(); }\n" +
				"interface J { Y foo(); }\n" +
				"interface K extends I, J {}\n" +
				"class X {}\n" +
				"class Y extends X {}\n";
		
		this.workingCopy = getWorkingCopy("/Converter18/src/X.java", true);
		ASTNode node = buildAST(contents, this.workingCopy);
		assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
		CompilationUnit compilationUnit = (CompilationUnit) node;
		assertProblemsSize(compilationUnit, 0);
		
		TypeDeclaration type = (TypeDeclaration) getASTNode(compilationUnit, 0);
		assertEquals("Not a Type declaration", ASTNode.TYPE_DECLARATION, type.getNodeType());
		ITypeBinding binding = type.resolveBinding();
		assertNotNull("Binding should not be null", binding);
		IMethodBinding functionalInterfaceMethod = binding.getFunctionalInterfaceMethod();
		assertNotNull("Should not be a functional interface", functionalInterfaceMethod);
		
		type = (TypeDeclaration) getASTNode(compilationUnit, 1);
		assertEquals("Not a Type declaration", ASTNode.TYPE_DECLARATION, type.getNodeType());
		binding = type.resolveBinding();
		assertNotNull("Binding should not be null", binding);
		functionalInterfaceMethod = binding.getFunctionalInterfaceMethod();
		assertNotNull("Should be a functional interface", functionalInterfaceMethod);
		
		type = (TypeDeclaration) getASTNode(compilationUnit, 2);
		assertEquals("Not a Type declaration", ASTNode.TYPE_DECLARATION, type.getNodeType());
		binding = type.resolveBinding();
		assertNotNull("Binding should not be null", binding);
		functionalInterfaceMethod = binding.getFunctionalInterfaceMethod();
		assertNotNull("Should be a functional interface", functionalInterfaceMethod);
		ITypeBinding returnType = functionalInterfaceMethod.getReturnType();
		assertEquals("Y", returnType.getName());
	}

// round-trip for binding keys of CaptureBinding18:
public void testBug425183a() throws JavaModelException {
	String contents = 
			"interface Comparator<T> {\n" +
			"    public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() { return null; }\n" +
			"}\n" + 
			"public class Bug425183a {\n" +
			"    @SuppressWarnings(\"unchecked\")\n" + 
			"	<T> void test() {\n" + 
			"		Comparator<? super T> comparator = (Comparator<? super T>) Comparator.naturalOrder();\n" +
			"		System.out.println(\"OK\");\n" + 
			"	}\n" +
			"	public static void main(String[] args) {\n" +
			"		new Bug425183a().test();\n" +
			"	}\n" +
			"}\n";
	
	this.workingCopy = getWorkingCopy("/Converter18/src/Bug425183a.java", true);
	ASTNode node = buildAST(contents, this.workingCopy);
	assertEquals("Not a compilation unit", ASTNode.COMPILATION_UNIT, node.getNodeType());
	CompilationUnit compilationUnit = (CompilationUnit) node;
	assertProblemsSize(compilationUnit, 0);
	
	String selection = "naturalOrder";
	int start = contents.lastIndexOf(selection);
	int length = selection.length();

	IJavaElement[] elements = this.workingCopy.codeSelect(start, length);
	assertElementsEqual(
		"Unexpected elements",
		"naturalOrder() {key=LBug425183a~Comparator<>;.naturalOrder<T::Ljava/lang/Comparable<-TT;>;>()LComparator<TT;>;%<^{267#0};>} [in Comparator [in [Working copy] Bug425183a.java [in <default> [in src [in Converter18]]]]]",
		elements,
		true
	);
	IMethod method = (IMethod)elements[0];
	String[] keys = new String[] { method.getKey() };
	BindingRequestor requestor = new BindingRequestor();
	resolveASTs(new ICompilationUnit[] { this.workingCopy } , keys, requestor, getJavaProject("Converter18"), null);
	assertBindingsEqual(
			keys[0],
			requestor.getBindings(keys));
	
	// assert that KeyToSignature doesn't throw AIOOBE, the result containing '!*' is a workaround for now, see https://bugs.eclipse.org/429264
	assertEquals("wrong signature", "<T::Ljava.lang.Comparable<-TT;>;>()LComparator<!*>;", new BindingKey(method.getKey()).toSignature());
}
/**
 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=432051
 * 
 * @throws JavaModelException
 */
public void testBug432051() throws JavaModelException {
	String contents =
			"public class X {\n" +
			"     * Delete line '/**' above.\n" +
			"     *\n" +
			"     * @param a (for example 'QVector')\n" +
			"     * @param declaringMember the context for resolving (made in)\n" +
			"     * @return if\n" +
			"     */\n" +
			"    void foo() {\n" +
			"    }\n" +
			"}\n";
	this.workingCopy = getWorkingCopy("/Converter18/src/test432051/X.java", contents, true/*computeProblems*/);
	IJavaProject javaProject = this.workingCopy.getJavaProject();
	class BindingRequestor extends ASTRequestor {
		ITypeBinding _result = null;
		public void acceptBinding(String bindingKey, IBinding binding) {
			if (this._result == null && binding != null && binding.getKind() == IBinding.TYPE)
				this._result = (ITypeBinding) binding;
		}
	}
	final BindingRequestor requestor = new BindingRequestor();
	final ASTParser parser = ASTParser.newParser(AST.JLS8);
	parser.setResolveBindings(false);
	parser.setProject(javaProject);
	try {
		parser.createASTs(new ICompilationUnit[] {this.workingCopy}, new String[0], requestor, null);
	} catch (IllegalArgumentException e) {
		assertTrue("Test Failed", false);
	}
}
}