Attachment #87590 for bug #191090

View | Details | Raw Unified | Return to bug 191090 | Differences between
Collapse All | Expand All




import org.eclipse.jdt.internal.compiler.lookup.TypeConstants;
import org.eclipse.jdt.internal.compiler.lookup.TypeIds;
import org.eclipse.jdt.internal.compiler.problem.ProblemSeverities;
import org.eclipse.jdt.internal.compiler.problem.ShouldNotImplement;
import org.eclipse.jdt.internal.compiler.util.Messages;
import org.eclipse.jdt.internal.compiler.util.Util;


			contents[contentsOffset++] = methodIndexByte2;
			attributeNumber++;
		}
		if (this.targetJDK >= ClassFileConstants.JDK1_5) {
			TypeDeclaration typeDeclaration = referenceBinding.scope.referenceContext;
			if (typeDeclaration != null) {
				final Annotation[] annotations = typeDeclaration.annotations;

			contents[contentsOffset++] = (byte) signatureIndex;
			attributesNumber++;
		}
		if (this.targetJDK >= ClassFileConstants.JDK1_5) {
			FieldDeclaration fieldDeclaration = fieldBinding.sourceField();
			if (fieldDeclaration != null) {
				Annotation[] annotations = fieldDeclaration.annotations;

		// always clear the strictfp/native/abstract bit for a problem method
		generateMethodInfoHeader(methodBinding, methodBinding.modifiers & ~(ClassFileConstants.AccStrictfp | ClassFileConstants.AccNative | ClassFileConstants.AccAbstract));
		int methodAttributeOffset = contentsOffset;
		int attributeNumber = generateMethodInfoAttribute(methodBinding);

		// Code attribute
		attributeNumber++;

		// always clear the strictfp/native/abstract bit for a problem method
		generateMethodInfoHeader(methodBinding, methodBinding.modifiers & ~(ClassFileConstants.AccStrictfp | ClassFileConstants.AccNative | ClassFileConstants.AccAbstract));
		int methodAttributeOffset = contentsOffset;
		int attributeNumber = generateMethodInfoAttribute(methodBinding);

		// Code attribute
		attributeNumber++;

		return constantPool.UTF8Cache.returnKeyFor(2);
	}

	private void generateAnnotation(Annotation annotation, int currentOffset) {
		int startingContentsOffset = currentOffset;
		if (contentsOffset + 4 >= this.contents.length) {
			resizeContents(4);
		}
		TypeBinding annotationTypeBinding = annotation.resolvedType;
		if (annotationTypeBinding == null) {
			this.contentsOffset = startingContentsOffset;
			return;
		}
		final int typeIndex = constantPool.literalIndex(annotationTypeBinding.signature());

					contents[contentsOffset++] = (byte) elementNameIndex;
					MethodBinding methodBinding = memberValuePair.binding;
					if (methodBinding == null) {
						contentsOffset = startingContentsOffset;
					} else {
						try {
							generateElementValue(memberValuePair.value, methodBinding.returnType, startingContentsOffset);
						} catch(ClassCastException e) {
							contentsOffset = startingContentsOffset;
						} catch(ShouldNotImplement e) {
							contentsOffset = startingContentsOffset;
						}
					}
				}
			} else {

			contents[contentsOffset++] = (byte) elementNameIndex;
			MethodBinding methodBinding = singleMemberAnnotation.memberValuePairs()[0].binding;
			if (methodBinding == null) {
				contentsOffset = startingContentsOffset;
			} else {
				try {
					generateElementValue(singleMemberAnnotation.memberValue, methodBinding.returnType, startingContentsOffset);
				} catch(ClassCastException e) {
					contentsOffset = startingContentsOffset;
				} catch(ShouldNotImplement e) {
					contentsOffset = startingContentsOffset;
				}
			}
		} else {
			// this is a marker annotation (no member value pairs)

			contentsOffset = attributeOffset;
		}
	}

	public int generateMethodInfoAttribute(MethodBinding methodBinding) {
		return generateMethodInfoAttribute(methodBinding, false);
	}

	public int generateMethodInfoAttribute(MethodBinding methodBinding, AnnotationMethodDeclaration declaration) {
		int attributesNumber = generateMethodInfoAttribute(methodBinding);
		int attributeOffset = contentsOffset;

	 * @param methodBinding org.eclipse.jdt.internal.compiler.lookup.MethodBinding
	 * @return <CODE>int</CODE>
	 */
	public int generateMethodInfoAttribute(MethodBinding methodBinding) {
		// leave two bytes for the attribute_number
		contentsOffset += 2;
		if (contentsOffset + 2 >= this.contents.length) {

			contents[contentsOffset++] = (byte) signatureIndex;
			attributeNumber++;
		}
		if (this.targetJDK >= ClassFileConstants.JDK1_5) {
			AbstractMethodDeclaration methodDeclaration = methodBinding.sourceMethod();
			if (methodDeclaration != null) {
				Annotation[] annotations = methodDeclaration.annotations;

			}
		}

		int annotationAttributeOffset = contentsOffset;
		if (invisibleAnnotationsCounter != 0) {
			int annotationAttributeOffset = contentsOffset;
			if (contentsOffset + 10 >= contents.length) {
				resizeContents(10);
			}

			int annotationsLengthOffset = contentsOffset;
			contentsOffset += 2; // leave space for the annotations length

			int counter = 0;
			contents[annotationsLengthOffset++] = (byte) invisibleAnnotationsCounter;

			loop: for (int i = 0; i < length; i++) {
				if (invisibleAnnotationsCounter == 0) break loop;
				Annotation annotation = annotations[i];
				if (isRuntimeInvisible(annotation)) {
					int currentAnnotationOffset = this.contentsOffset;
					generateAnnotation(annotation, currentAnnotationOffset);
					invisibleAnnotationsCounter--;
					if (this.contentsOffset != currentAnnotationOffset) {
						counter++;
					}
				}
			}
			if (counter != 0) {
				contents[annotationsLengthOffset++] = (byte) (counter >> 8);
				contents[annotationsLengthOffset++] = (byte) counter;

				int attributeLength = contentsOffset - attributeLengthOffset - 4;
				contents[attributeLengthOffset++] = (byte) (attributeLength >> 24);
				contents[attributeLengthOffset++] = (byte) (attributeLength >> 16);

			}
		}

		annotationAttributeOffset = contentsOffset;
		if (visibleAnnotationsCounter != 0) {
			int annotationAttributeOffset = contentsOffset;
			if (contentsOffset + 10 >= contents.length) {
				resizeContents(10);
			}

			int annotationsLengthOffset = contentsOffset;
			contentsOffset += 2; // leave space for the annotations length

			int counter = 0;
			contents[annotationsLengthOffset++] = (byte) visibleAnnotationsCounter;

			loop: for (int i = 0; i < length; i++) {
				if (visibleAnnotationsCounter == 0) break loop;
				Annotation annotation = annotations[i];
				if (isRuntimeVisible(annotation)) {
					visibleAnnotationsCounter--;
					int currentAnnotationOffset = this.contentsOffset;
					generateAnnotation(annotation, currentAnnotationOffset);
					if (this.contentsOffset != currentAnnotationOffset) {
						counter++;
					}
				}
			}
			if (counter != 0) {
				contents[annotationsLengthOffset++] = (byte) (counter >> 8);
				contents[annotationsLengthOffset++] = (byte) counter;

				int attributeLength = contentsOffset - attributeLengthOffset - 4;
				contents[attributeLengthOffset++] = (byte) (attributeLength >> 24);
				contents[attributeLengthOffset++] = (byte) (attributeLength >> 16);

		int attributesNumber = 0;
		int annotationAttributeOffset = contentsOffset;
		if (invisibleParametersAnnotationsCounter != 0) {
			int globalCounter = 0;
			if (contentsOffset + 7 >= contents.length) {
				resizeContents(7);
			}

			contentsOffset += 4; // leave space for the attribute length

			contents[contentsOffset++] = (byte) argumentsLength;
			for (int i = 0; i < argumentsLength; i++) {
				if (contentsOffset + 2 >= contents.length) {
					resizeContents(2);
				}

					contents[contentsOffset++] = (byte) 0;
				} else {
					final int numberOfInvisibleAnnotations = annotationsCounters[i][INVISIBLE_INDEX];
					int invisibleAnnotationsOffset = this.contentsOffset;
					// leave space for number of annotations
					this.contentsOffset += 2;
					int counter = 0;
					if (numberOfInvisibleAnnotations != 0) {
						Argument argument = arguments[i];
						Annotation[] annotations = argument.annotations;
						for (int j = 0, max = annotations.length; j < max; j++) {
							Annotation annotation = annotations[j];
							if (isRuntimeInvisible(annotation)) {
								int currentAnnotationOffset = this.contentsOffset;
								generateAnnotation(annotation, currentAnnotationOffset);
								if (contentsOffset != currentAnnotationOffset) {
									counter++;
									globalCounter++;
								}
								invisibleParametersAnnotationsCounter--;
							}
						}
					}
					contents[invisibleAnnotationsOffset++] = (byte) (counter >> 8);
					contents[invisibleAnnotationsOffset] = (byte) counter;
				}
			}
			if (globalCounter != 0) {
				int attributeLength = contentsOffset - attributeLengthOffset - 4;
				contents[attributeLengthOffset++] = (byte) (attributeLength >> 24);
				contents[attributeLengthOffset++] = (byte) (attributeLength >> 16);

				contents[attributeLengthOffset++] = (byte) attributeLength;
				attributesNumber++;
			} else {
				// if globalCounter is 0, this means that the code generation for all visible annotations failed
				contentsOffset = annotationAttributeOffset;
			}
		}
		if (visibleParametersAnnotationsCounter != 0) {
			int globalCounter = 0;
			if (contentsOffset + 7 >= contents.length) {
				resizeContents(7);
			}

			contentsOffset += 4; // leave space for the attribute length

			contents[contentsOffset++] = (byte) argumentsLength;
			for (int i = 0; i < argumentsLength; i++) {
				if (contentsOffset + 2 >= contents.length) {
					resizeContents(2);
				}

					contents[contentsOffset++] = (byte) 0;
				} else {
					final int numberOfVisibleAnnotations = annotationsCounters[i][VISIBLE_INDEX];
					int visibleAnnotationsOffset = this.contentsOffset;
					// leave space for number of annotations
					this.contentsOffset += 2;
					int counter = 0;
					if (numberOfVisibleAnnotations != 0) {
						Argument argument = arguments[i];
						Annotation[] annotations = argument.annotations;
						for (int j = 0, max = annotations.length; j < max; j++) {
							Annotation annotation = annotations[j];
							if (isRuntimeVisible(annotation)) {
								int currentAnnotationOffset = this.contentsOffset;
								generateAnnotation(annotation, currentAnnotationOffset);
								if (contentsOffset != currentAnnotationOffset) {
									counter++;
									globalCounter++;
								}
								visibleParametersAnnotationsCounter--;
							}
						}
					}
					contents[visibleAnnotationsOffset++] = (byte) (counter >> 8);
					contents[visibleAnnotationsOffset] = (byte) counter;
				}
			}
			if (globalCounter != 0) {
				int attributeLength = contentsOffset - attributeLengthOffset - 4;
				contents[attributeLengthOffset++] = (byte) (attributeLength >> 24);
				contents[attributeLengthOffset++] = (byte) (attributeLength >> 16);

				contents[attributeLengthOffset++] = (byte) attributeLength;
				attributesNumber++;
			} else {
				// if globalCounter is 0, this means that the code generation for all visible annotations failed
				contentsOffset = annotationAttributeOffset;
			}
		}




	// All specified tests which do not belong to the class are skipped...
	static {
//		TESTS_NAMES = new String[] { "test127" };
//		TESTS_NUMBERS = new int[] { 249 };
//		TESTS_RANGE = new int[] { 249, -1 };
	}

	public static Test suite() {

				ClassFileBytesDisassembler.DETAILED); 
		
		String expectedOutput = 
			"  // Method descriptor #6 ()V\n" + 
			"  // Stack: 0, Locals: 1\n" + 
			"  @I(enums={Color.RED},\n" + 
			"    annotations={@Foo},\n" + 
			"    ints={(int) 2},\n" + 
			"    bytes={(byte) 1},\n" + 
			"    shorts={(short) 5},\n" + 
			"    longs={-9223372036854775808L},\n" + 
			"    strings={\"Hi\"},\n" + 
			"    booleans={true},\n" + 
			"    floats={0.0f},\n" + 
			"    doubles={-0.0})\n" + 
			"  void foo();";

		int index = actualOutput.indexOf(expectedOutput);
		if (index == -1 || expectedOutput.length() == 0) {

				ClassFileBytesDisassembler.DETAILED); 
		
		String expectedOutput = 
			"  // Method descriptor #6 ()V\n" + 
			"  // Stack: 0, Locals: 1\n" + 
			"  @I(enums=Color.RED,\n" + 
			"    annotations=@Foo,\n" + 
			"    ints=(int) 2,\n" + 
			"    bytes=(byte) 1,\n" + 
			"    shorts=(short) 5,\n" + 
			"    longs=-9223372036854775808L,\n" + 
			"    strings=\"Hi\",\n" + 
			"    booleans=true,\n" + 
			"    floats=0.0f,\n" + 
			"    doubles=-0.0)\n" + 
			"  void foo();";
			
		int index = actualOutput.indexOf(expectedOutput);
		if (index == -1 || expectedOutput.length() == 0) {

			"Type mismatch: cannot convert from Class<Void> to String\n" + 
			"----------\n");
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
public void test249() throws Exception {
	this.runNegativeTest(
		new String[] {
			"X.java", //-----------------------------------------------------------------------
			"@Zork\n" +
			"public class X {}",
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 1)\n" + 
		"	@Zork\n" + 
		"	 ^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\n",
		null,
		true, // flush output
		null,
		true, // generate output
		false,
		false);
	String expectedOutput = "public class X {";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
public void test250() throws Exception {
	this.runNegativeTest(
		new String[] {
			"X.java", //-----------------------------------------------------------------------
			"@Deprecated\n" +
			"@Zork\n" +
			"@Annot(1)\n" +
			"public class X {}",
			"Annot.java",
			"import java.lang.annotation.Retention;\n" +
			"import static java.lang.annotation.RetentionPolicy.*;\n" +
			"@Retention(RUNTIME)\n" +
			"@interface Annot {\n" +
			"	int value() default -1;\n" +
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	@Zork\n" + 
		"	 ^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\n",
		null,
		true, // flush output
		null,
		true, // generate output
		false,
		false);
	String expectedOutput =
		"@java.lang.Deprecated\n" + 
		"@Annot(value=(int) 1)\n" + 
		"public class X {";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
public void test251() throws Exception {
	this.runNegativeTest(
		new String[] {
			"X.java", //-----------------------------------------------------------------------
			"@Deprecated\n" +
			"@Zork\n" +
			"@Annot(1)\n" +
			"public class X {}",
			"Annot.java",
			"import java.lang.annotation.Retention;\n" +
			"import static java.lang.annotation.RetentionPolicy.*;\n" +
			"@Retention(CLASS)\n" +
			"@interface Annot {\n" +
			"	int value() default -1;\n" +
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	@Zork\n" + 
		"	 ^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\n",
		null,
		true, // flush output
		null,
		true, // generate output
		false,
		false);
	String expectedOutput =
		"@Annot(value=(int) 1)\n" + 
		"@java.lang.Deprecated\n" + 
		"public class X {";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
public void test252() throws Exception {
	this.runNegativeTest(
		new String[] {
			"X.java", //-----------------------------------------------------------------------
			"public class X {\n" +
			"	public void foo(@Deprecated @Zork @Annot(2) int i) {}\n" +
			"}",
			"Annot.java",
			"import java.lang.annotation.Retention;\n" +
			"import static java.lang.annotation.RetentionPolicy.*;\n" +
			"@Retention(CLASS)\n" +
			"@interface Annot {\n" +
			"	int value() default -1;\n" +
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	public void foo(@Deprecated @Zork @Annot(2) int i) {}\n" + 
		"	                             ^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\n",
		null,
		true, // flush output
		null,
		true, // generate output
		false,
		false);
	String expectedOutput =
		"    RuntimeVisibleParameterAnnotations: \n" + 
		"      Number of annotations for parameter 0: 1\n" + 
		"        #21 @java.lang.Deprecated(\n" + 
		"        )\n" + 
		"    RuntimeInvisibleParameterAnnotations: \n" + 
		"      Number of annotations for parameter 0: 1\n" + 
		"        #17 @Annot(\n" + 
		"          #18 value=(int) 2 (constant type)\n" + 
		"        )\n";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
public void test253() throws Exception {
	this.runNegativeTest(
		new String[] {
			"X.java", //-----------------------------------------------------------------------
			"public class X {\n" +
			"	public void foo(@Deprecated @Zork @Annot(2) int i) {}\n" +
			"}",
			"Annot.java",
			"import java.lang.annotation.Retention;\n" +
			"import static java.lang.annotation.RetentionPolicy.*;\n" +
			"@Retention(RUNTIME)\n" +
			"@interface Annot {\n" +
			"	int value() default -1;\n" +
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	public void foo(@Deprecated @Zork @Annot(2) int i) {}\n" + 
		"	                             ^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\n",
		null,
		true, // flush output
		null,
		true, // generate output
		false,
		false);
	String expectedOutput =
		"    RuntimeVisibleParameterAnnotations: \n" + 
		"      Number of annotations for parameter 0: 2\n" + 
		"        #17 @java.lang.Deprecated(\n" + 
		"        )\n" + 
		"        #18 @Annot(\n" + 
		"          #19 value=(int) 2 (constant type)\n" + 
		"        )\n";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
public void test254() throws Exception {
	this.runNegativeTest(
		new String[] {
			"X.java", //-----------------------------------------------------------------------
			"public class X {\n" +
			"	public void foo(@Deprecated int j, @Zork @Annot(3) int i) {}\n" +
			"}",
			"Annot.java",
			"import java.lang.annotation.Retention;\n" +
			"import static java.lang.annotation.RetentionPolicy.*;\n" +
			"@Retention(RUNTIME)\n" +
			"@interface Annot {\n" +
			"	int value() default -1;\n" +
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	public void foo(@Deprecated int j, @Zork @Annot(3) int i) {}\n" + 
		"	                                    ^^^^\n" + 
		"Zork cannot be resolved to a type\n" + 
		"----------\n",
		null,
		true, // flush output
		null,
		true, // generate output
		false,
		false);
	String expectedOutput =
		"    RuntimeVisibleParameterAnnotations: \n" + 
		"      Number of annotations for parameter 0: 1\n" + 
		"        #17 @java.lang.Deprecated(\n" + 
		"        )\n" + 
		"      Number of annotations for parameter 1: 1\n" + 
		"        #18 @Annot(\n" + 
		"          #19 value=(int) 3 (constant type)\n" + 
		"        )\n";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
public void test255() throws Exception {
	this.runNegativeTest(
		new String[] {
			"X.java", //-----------------------------------------------------------------------
			"public class X {\n" +
			"	public void foo(@Deprecated int j, @Annot(\"\") @Deprecated int i) {}\n" +
			"}",
			"Annot.java",
			"import java.lang.annotation.Retention;\n" +
			"import static java.lang.annotation.RetentionPolicy.*;\n" +
			"@Retention(RUNTIME)\n" +
			"@interface Annot {\n" +
			"	int value() default -1;\n" +
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	public void foo(@Deprecated int j, @Annot(\"\") @Deprecated int i) {}\n" + 
		"	                                          ^^\n" + 
		"Type mismatch: cannot convert from String to int\n" + 
		"----------\n",
		null,
		true, // flush output
		null,
		true, // generate output
		false,
		false);
	String expectedOutput =
		"    RuntimeVisibleParameterAnnotations: \n" + 
		"      Number of annotations for parameter 0: 1\n" + 
		"        #17 @java.lang.Deprecated(\n" + 
		"        )\n" + 
		"      Number of annotations for parameter 1: 1\n" + 
		"        #17 @java.lang.Deprecated(\n" + 
		"        )\n";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
public void test256() throws Exception {
	this.runNegativeTest(
		new String[] {
			"X.java", //-----------------------------------------------------------------------
			"public class X {\n" +
			"	public void foo(@Deprecated int j, @Annot(\"\") @Deprecated int i) {}\n" +
			"}",
			"Annot.java",
			"import java.lang.annotation.Retention;\n" +
			"import static java.lang.annotation.RetentionPolicy.*;\n" +
			"@Retention(CLASS)\n" +
			"@interface Annot {\n" +
			"	int value() default -1;\n" +
			"}"
		},
		"----------\n" + 
		"1. ERROR in X.java (at line 2)\n" + 
		"	public void foo(@Deprecated int j, @Annot(\"\") @Deprecated int i) {}\n" + 
		"	                                          ^^\n" + 
		"Type mismatch: cannot convert from String to int\n" + 
		"----------\n",
		null,
		true, // flush output
		null,
		true, // generate output
		false,
		false);
	String expectedOutput =
		"    RuntimeVisibleParameterAnnotations: \n" + 
		"      Number of annotations for parameter 0: 1\n" + 
		"        #20 @java.lang.Deprecated(\n" + 
		"        )\n" + 
		"      Number of annotations for parameter 1: 1\n" + 
		"        #20 @java.lang.Deprecated(\n" + 
		"        )";
	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
}
}

Return to bug 191090

Lines 39-46 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/AnnotationTest.java (-26 / +308 lines)
39	// All specified tests which do not belong to the class are skipped...	39	// All specified tests which do not belong to the class are skipped...
40	static {	40	static {
41	// TESTS_NAMES = new String[] { "test127" };	41	// TESTS_NAMES = new String[] { "test127" };
42	// TESTS_NUMBERS = new int[] { 248 };	42	// TESTS_NUMBERS = new int[] { 249 };
43	// TESTS_RANGE = new int[] { 219, -1 };	43	// TESTS_RANGE = new int[] { 249, -1 };
44	}	44	}
45		45
46	public static Test suite() {	46	public static Test suite() {
Lines 1685-1703 Link Here
1685	ClassFileBytesDisassembler.DETAILED);	1685	ClassFileBytesDisassembler.DETAILED);
1686		1686
1687	String expectedOutput =	1687	String expectedOutput =
1688	" // Method descriptor #6 ()V\n" +
1689	" // Stack: 0, Locals: 1\n" +
1690	" @I(enums={Color.RED},\n" +	1688	" @I(enums={Color.RED},\n" +
1691	" annotations={@Foo},\n" +	1689	" annotations={@Foo},\n" +
1692	" ints={(int) 2},\n" +	1690	" ints={(int) 2},\n" +
1693	" bytes={(byte) 1},\n" +	1691	" bytes={(byte) 1},\n" +
1694	" shorts={(short) 5},\n" +	1692	" shorts={(short) 5},\n" +
1695	" longs={-9223372036854775808L},\n" +	1693	" longs={-9223372036854775808L},\n" +
1696	" strings={\"Hi\"},\n" +	1694	" strings={\"Hi\"},\n" +
1697	" booleans={true},\n" +	1695	" booleans={true},\n" +
1698	" floats={0.0f},\n" +	1696	" floats={0.0f},\n" +
1699	" doubles={-0.0})\n" +	1697	" doubles={-0.0})\n" +
1700	" void foo();";	1698	" void foo();";
1701		1699
1702	int index = actualOutput.indexOf(expectedOutput);	1700	int index = actualOutput.indexOf(expectedOutput);
1703	if (index == -1 \|\| expectedOutput.length() == 0) {	1701	if (index == -1 \|\| expectedOutput.length() == 0) {
Lines 1757-1775 Link Here
1757	ClassFileBytesDisassembler.DETAILED);	1755	ClassFileBytesDisassembler.DETAILED);
1758		1756
1759	String expectedOutput =	1757	String expectedOutput =
1760	" // Method descriptor #6 ()V\n" +
1761	" // Stack: 0, Locals: 1\n" +
1762	" @I(enums=Color.RED,\n" +	1758	" @I(enums=Color.RED,\n" +
1763	" annotations=@Foo,\n" +	1759	" annotations=@Foo,\n" +
1764	" ints=(int) 2,\n" +	1760	" ints=(int) 2,\n" +
1765	" bytes=(byte) 1,\n" +	1761	" bytes=(byte) 1,\n" +
1766	" shorts=(short) 5,\n" +	1762	" shorts=(short) 5,\n" +
1767	" longs=-9223372036854775808L,\n" +	1763	" longs=-9223372036854775808L,\n" +
1768	" strings=\"Hi\",\n" +	1764	" strings=\"Hi\",\n" +
1769	" booleans=true,\n" +	1765	" booleans=true,\n" +
1770	" floats=0.0f,\n" +	1766	" floats=0.0f,\n" +
1771	" doubles=-0.0)\n" +	1767	" doubles=-0.0)\n" +
1772	" void foo();";	1768	" void foo();";
1773		1769
1774	int index = actualOutput.indexOf(expectedOutput);	1770	int index = actualOutput.indexOf(expectedOutput);
1775	if (index == -1 \|\| expectedOutput.length() == 0) {	1771	if (index == -1 \|\| expectedOutput.length() == 0) {
Lines 7992-7995 Link Here
7992	"Type mismatch: cannot convert from Class<Void> to String\n" +	7988	"Type mismatch: cannot convert from Class<Void> to String\n" +
7993	"----------\n");	7989	"----------\n");
7994	}	7990	}
		7991	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
		7992	public void test249() throws Exception {
		7993	this.runNegativeTest(
		7994	new String[] {
		7995	"X.java", //-----------------------------------------------------------------------
		7996	"@Zork\n" +
		7997	"public class X {}",
		7998	},
		7999	"----------\n" +
		8000	"1. ERROR in X.java (at line 1)\n" +
		8001	" @Zork\n" +
		8002	" ^^^^\n" +
		8003	"Zork cannot be resolved to a type\n" +
		8004	"----------\n",
		8005	null,
		8006	true, // flush output
		8007	null,
		8008	true, // generate output
		8009	false,
		8010	false);
		8011	String expectedOutput = "public class X {";
		8012	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
		8013	}
		8014	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
		8015	public void test250() throws Exception {
		8016	this.runNegativeTest(
		8017	new String[] {
		8018	"X.java", //-----------------------------------------------------------------------
		8019	"@Deprecated\n" +
		8020	"@Zork\n" +
		8021	"@Annot(1)\n" +
		8022	"public class X {}",
		8023	"Annot.java",
		8024	"import java.lang.annotation.Retention;\n" +
		8025	"import static java.lang.annotation.RetentionPolicy.*;\n" +
		8026	"@Retention(RUNTIME)\n" +
		8027	"@interface Annot {\n" +
		8028	" int value() default -1;\n" +
		8029	"}"
		8030	},
		8031	"----------\n" +
		8032	"1. ERROR in X.java (at line 2)\n" +
		8033	" @Zork\n" +
		8034	" ^^^^\n" +
		8035	"Zork cannot be resolved to a type\n" +
		8036	"----------\n",
		8037	null,
		8038	true, // flush output
		8039	null,
		8040	true, // generate output
		8041	false,
		8042	false);
		8043	String expectedOutput =
		8044	"@java.lang.Deprecated\n" +
		8045	"@Annot(value=(int) 1)\n" +
		8046	"public class X {";
		8047	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
		8048	}
		8049	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
		8050	public void test251() throws Exception {
		8051	this.runNegativeTest(
		8052	new String[] {
		8053	"X.java", //-----------------------------------------------------------------------
		8054	"@Deprecated\n" +
8055	"@Zork\n" +
8056	"@Annot(1)\n" +
8057	"public class X {}",
8058	"Annot.java",
8059	"import java.lang.annotation.Retention;\n" +
8060	"import static java.lang.annotation.RetentionPolicy.*;\n" +
8061	"@Retention(CLASS)\n" +
8062	"@interface Annot {\n" +
8063	" int value() default -1;\n" +
8064	"}"
8065	},
8066	"----------\n" +
8067	"1. ERROR in X.java (at line 2)\n" +
8068	" @Zork\n" +
8069	" ^^^^\n" +
8070	"Zork cannot be resolved to a type\n" +
8071	"----------\n",
8072	null,
8073	true, // flush output
8074	null,
8075	true, // generate output
8076	false,
8077	false);
8078	String expectedOutput =
8079	"@Annot(value=(int) 1)\n" +
8080	"@java.lang.Deprecated\n" +
8081	"public class X {";
8082	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput);
8083	}
8084	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
8085	public void test252() throws Exception {
8086	this.runNegativeTest(
8087	new String[] {
8088	"X.java", //-----------------------------------------------------------------------
8089	"public class X {\n" +
8090	" public void foo(@Deprecated @Zork @Annot(2) int i) {}\n" +
8091	"}",
8092	"Annot.java",
8093	"import java.lang.annotation.Retention;\n" +
8094	"import static java.lang.annotation.RetentionPolicy.*;\n" +
8095	"@Retention(CLASS)\n" +
8096	"@interface Annot {\n" +
8097	" int value() default -1;\n" +
8098	"}"
8099	},
8100	"----------\n" +
8101	"1. ERROR in X.java (at line 2)\n" +
8102	" public void foo(@Deprecated @Zork @Annot(2) int i) {}\n" +
8103	" ^^^^\n" +
8104	"Zork cannot be resolved to a type\n" +
8105	"----------\n",
8106	null,
8107	true, // flush output
8108	null,
8109	true, // generate output
8110	false,
8111	false);
8112	String expectedOutput =
8113	" RuntimeVisibleParameterAnnotations: \n" +
8114	" Number of annotations for parameter 0: 1\n" +
8115	" #21 @java.lang.Deprecated(\n" +
8116	" )\n" +
8117	" RuntimeInvisibleParameterAnnotations: \n" +
8118	" Number of annotations for parameter 0: 1\n" +
8119	" #17 @Annot(\n" +
8120	" #18 value=(int) 2 (constant type)\n" +
8121	" )\n";
8122	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
8123	}
8124	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
8125	public void test253() throws Exception {
8126	this.runNegativeTest(
8127	new String[] {
8128	"X.java", //-----------------------------------------------------------------------
8129	"public class X {\n" +
8130	" public void foo(@Deprecated @Zork @Annot(2) int i) {}\n" +
8131	"}",
8132	"Annot.java",
8133	"import java.lang.annotation.Retention;\n" +
8134	"import static java.lang.annotation.RetentionPolicy.*;\n" +
8135	"@Retention(RUNTIME)\n" +
8136	"@interface Annot {\n" +
8137	" int value() default -1;\n" +
8138	"}"
8139	},
8140	"----------\n" +
8141	"1. ERROR in X.java (at line 2)\n" +
8142	" public void foo(@Deprecated @Zork @Annot(2) int i) {}\n" +
8143	" ^^^^\n" +
8144	"Zork cannot be resolved to a type\n" +
8145	"----------\n",
8146	null,
8147	true, // flush output
8148	null,
8149	true, // generate output
8150	false,
8151	false);
8152	String expectedOutput =
8153	" RuntimeVisibleParameterAnnotations: \n" +
8154	" Number of annotations for parameter 0: 2\n" +
8155	" #17 @java.lang.Deprecated(\n" +
8156	" )\n" +
8157	" #18 @Annot(\n" +
8158	" #19 value=(int) 2 (constant type)\n" +
8159	" )\n";
8160	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
8161	}
8162	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
8163	public void test254() throws Exception {
8164	this.runNegativeTest(
8165	new String[] {
8166	"X.java", //-----------------------------------------------------------------------
8167	"public class X {\n" +
8168	" public void foo(@Deprecated int j, @Zork @Annot(3) int i) {}\n" +
8169	"}",
8170	"Annot.java",
8171	"import java.lang.annotation.Retention;\n" +
8172	"import static java.lang.annotation.RetentionPolicy.*;\n" +
8173	"@Retention(RUNTIME)\n" +
8174	"@interface Annot {\n" +
8175	" int value() default -1;\n" +
8176	"}"
8177	},
8178	"----------\n" +
8179	"1. ERROR in X.java (at line 2)\n" +
8180	" public void foo(@Deprecated int j, @Zork @Annot(3) int i) {}\n" +
8181	" ^^^^\n" +
8182	"Zork cannot be resolved to a type\n" +
8183	"----------\n",
8184	null,
8185	true, // flush output
8186	null,
8187	true, // generate output
8188	false,
8189	false);
8190	String expectedOutput =
8191	" RuntimeVisibleParameterAnnotations: \n" +
8192	" Number of annotations for parameter 0: 1\n" +
8193	" #17 @java.lang.Deprecated(\n" +
8194	" )\n" +
8195	" Number of annotations for parameter 1: 1\n" +
8196	" #18 @Annot(\n" +
8197	" #19 value=(int) 3 (constant type)\n" +
8198	" )\n";
8199	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
8200	}
8201	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
8202	public void test255() throws Exception {
8203	this.runNegativeTest(
8204	new String[] {
8205	"X.java", //-----------------------------------------------------------------------
8206	"public class X {\n" +
8207	" public void foo(@Deprecated int j, @Annot(\"\") @Deprecated int i) {}\n" +
8208	"}",
8209	"Annot.java",
8210	"import java.lang.annotation.Retention;\n" +
8211	"import static java.lang.annotation.RetentionPolicy.*;\n" +
8212	"@Retention(RUNTIME)\n" +
8213	"@interface Annot {\n" +
8214	" int value() default -1;\n" +
8215	"}"
8216	},
8217	"----------\n" +
8218	"1. ERROR in X.java (at line 2)\n" +
8219	" public void foo(@Deprecated int j, @Annot(\"\") @Deprecated int i) {}\n" +
8220	" ^^\n" +
8221	"Type mismatch: cannot convert from String to int\n" +
8222	"----------\n",
8223	null,
8224	true, // flush output
8225	null,
8226	true, // generate output
8227	false,
8228	false);
8229	String expectedOutput =
8230	" RuntimeVisibleParameterAnnotations: \n" +
8231	" Number of annotations for parameter 0: 1\n" +
8232	" #17 @java.lang.Deprecated(\n" +
8233	" )\n" +
8234	" Number of annotations for parameter 1: 1\n" +
8235	" #17 @java.lang.Deprecated(\n" +
8236	" )\n";
8237	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
8238	}
8239	//https://bugs.eclipse.org/bugs/show_bug.cgi?id=191090
8240	public void test256() throws Exception {
8241	this.runNegativeTest(
8242	new String[] {
8243	"X.java", //-----------------------------------------------------------------------
8244	"public class X {\n" +
8245	" public void foo(@Deprecated int j, @Annot(\"\") @Deprecated int i) {}\n" +
8246	"}",
8247	"Annot.java",
8248	"import java.lang.annotation.Retention;\n" +
8249	"import static java.lang.annotation.RetentionPolicy.*;\n" +
8250	"@Retention(CLASS)\n" +
8251	"@interface Annot {\n" +
8252	" int value() default -1;\n" +
8253	"}"
8254	},
8255	"----------\n" +
8256	"1. ERROR in X.java (at line 2)\n" +
8257	" public void foo(@Deprecated int j, @Annot(\"\") @Deprecated int i) {}\n" +
8258	" ^^\n" +
8259	"Type mismatch: cannot convert from String to int\n" +
8260	"----------\n",
8261	null,
8262	true, // flush output
8263	null,
8264	true, // generate output
8265	false,
8266	false);
8267	String expectedOutput =
8268	" RuntimeVisibleParameterAnnotations: \n" +
8269	" Number of annotations for parameter 0: 1\n" +
8270	" #20 @java.lang.Deprecated(\n" +
8271	" )\n" +
8272	" Number of annotations for parameter 1: 1\n" +
8273	" #20 @java.lang.Deprecated(\n" +
8274	" )";
8275	checkDisassembledClassFile(OUTPUT_DIR + File.separator + "X.class", "X", expectedOutput, ClassFileBytesDisassembler.SYSTEM);
8276	}
7995	}	8277	}