Attachment #146103 for bug #287772




		}
	}
}
static public void assertSame(int expected, int actual) {
	assertSame(null, expected, actual);
}
static public void assertSame(String message, int expected, int actual) {
	if (expected == actual)
		return;
	failNotSame(message, expected, actual);
}
static public void failNotSame(String message, int expected, int actual) {
	StringBuffer formatted= new StringBuffer();
	if (message != null) {
		formatted.append(message).append(' ');
	}
	formatted.append("expected same:<").append(expected).append("> was not:<").append(actual).append(">");
	fail(String.valueOf(formatted));
}
}

Lines 74-83 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTParserTest.java (-4 / +4 lines)
74	}	74	}
75		75
76	public void testKConstants() {	76	public void testKConstants() {
77	assertTrue(ASTParser.K_EXPRESSION == 1);	77	assertSame(ASTParser.K_EXPRESSION, 1);
78	assertTrue(ASTParser.K_STATEMENTS == 2);	78	assertSame(ASTParser.K_STATEMENTS, 2);
79	assertTrue(ASTParser.K_CLASS_BODY_DECLARATIONS == 4);	79	assertSame(ASTParser.K_CLASS_BODY_DECLARATIONS, 4);
80	assertTrue(ASTParser.K_COMPILATION_UNIT == 8);	80	assertSame(ASTParser.K_COMPILATION_UNIT, 8);
81	}	81	}
82		82
83	public void testSetting() {	83	public void testSetting() {




	/** @deprecated using deprecated code */
	public void testAST() {

		assertSame(AST.JLS2, 2);
		assertSame(AST.JLS3, 3);

		AST a0 = new AST(); // deprecated, but still 2.0
		assertTrue(a0.apiLevel() == AST.JLS2);

	public void testModifiers() {

		// check all modifiers match their JVM spec values
		assertSame(Modifier.ABSTRACT ,0x0400);
		assertSame(Modifier.FINAL ,0x0010);
		assertSame(Modifier.NATIVE ,0x0100);
		assertSame(Modifier.NONE ,0x0000);
		assertSame(Modifier.PRIVATE ,0x0002);
		assertSame(Modifier.PROTECTED ,0x0004);
		assertSame(Modifier.PUBLIC ,0x0001);
		assertSame(Modifier.STATIC ,0x0008);
		assertSame(Modifier.STRICTFP ,0x0800);
		assertSame(Modifier.SYNCHRONIZED ,0x0020);
		assertSame(Modifier.TRANSIENT ,0x0080);
		assertSame(Modifier.VOLATILE ,0x0040);

		// check that all
		final int[] mods =

	public void testNodeTypeConstants() {
		// it would be a breaking API change to change the numeric values of
		// public static final ints
		assertSame(ASTNode.ANONYMOUS_CLASS_DECLARATION, 1);
		assertSame(ASTNode.ARRAY_ACCESS, 2);
		assertSame(ASTNode.ARRAY_CREATION, 3);
		assertSame(ASTNode.ARRAY_INITIALIZER, 4);
		assertSame(ASTNode.ARRAY_TYPE, 5);
		assertSame(ASTNode.ASSERT_STATEMENT, 6);
		assertSame(ASTNode.ASSIGNMENT, 7);
		assertSame(ASTNode.BLOCK, 8);
		assertSame(ASTNode.BOOLEAN_LITERAL, 9);
		assertSame(ASTNode.BREAK_STATEMENT, 10);
		assertSame(ASTNode.CAST_EXPRESSION, 11);
		assertSame(ASTNode.CATCH_CLAUSE, 12);
		assertSame(ASTNode.CHARACTER_LITERAL, 13);
		assertSame(ASTNode.CLASS_INSTANCE_CREATION, 14);
		assertSame(ASTNode.COMPILATION_UNIT, 15);
		assertSame(ASTNode.CONDITIONAL_EXPRESSION, 16);
		assertSame(ASTNode.CONSTRUCTOR_INVOCATION, 17);
		assertSame(ASTNode.CONTINUE_STATEMENT, 18);
		assertSame(ASTNode.DO_STATEMENT, 19);
		assertSame(ASTNode.EMPTY_STATEMENT, 20);
		assertSame(ASTNode.EXPRESSION_STATEMENT, 21);
		assertSame(ASTNode.FIELD_ACCESS, 22);
		assertSame(ASTNode.FIELD_DECLARATION, 23);
		assertSame(ASTNode.FOR_STATEMENT, 24);
		assertSame(ASTNode.IF_STATEMENT, 25);
		assertSame(ASTNode.IMPORT_DECLARATION, 26);
		assertSame(ASTNode.INFIX_EXPRESSION, 27);
		assertSame(ASTNode.INITIALIZER, 28);
		assertSame(ASTNode.JAVADOC, 29);
		assertSame(ASTNode.LABELED_STATEMENT, 30);
		assertSame(ASTNode.METHOD_DECLARATION, 31);
		assertSame(ASTNode.METHOD_INVOCATION, 32);
		assertSame(ASTNode.NULL_LITERAL, 33);
		assertSame(ASTNode.NUMBER_LITERAL, 34);
		assertSame(ASTNode.PACKAGE_DECLARATION, 35);
		assertSame(ASTNode.PARENTHESIZED_EXPRESSION, 36);
		assertSame(ASTNode.POSTFIX_EXPRESSION, 37);
		assertSame(ASTNode.PREFIX_EXPRESSION, 38);
		assertSame(ASTNode.PRIMITIVE_TYPE, 39);
		assertSame(ASTNode.QUALIFIED_NAME, 40);
		assertSame(ASTNode.RETURN_STATEMENT, 41);
		assertSame(ASTNode.SIMPLE_NAME, 42);
		assertSame(ASTNode.SIMPLE_TYPE, 43);
		assertSame(ASTNode.SINGLE_VARIABLE_DECLARATION, 44);
		assertSame(ASTNode.STRING_LITERAL, 45);
		assertSame(ASTNode.SUPER_CONSTRUCTOR_INVOCATION, 46);
		assertSame(ASTNode.SUPER_FIELD_ACCESS, 47);
		assertSame(ASTNode.SUPER_METHOD_INVOCATION, 48);
		assertSame(ASTNode.SWITCH_CASE, 49);
		assertSame(ASTNode.SWITCH_STATEMENT, 50);
		assertSame(ASTNode.SYNCHRONIZED_STATEMENT, 51);
		assertSame(ASTNode.THIS_EXPRESSION, 52);
		assertSame(ASTNode.THROW_STATEMENT, 53);
		assertSame(ASTNode.TRY_STATEMENT, 54);
		assertSame(ASTNode.TYPE_DECLARATION, 55);
		assertSame(ASTNode.TYPE_DECLARATION_STATEMENT, 56);
		assertSame(ASTNode.TYPE_LITERAL, 57);
		assertSame(ASTNode.VARIABLE_DECLARATION_EXPRESSION, 58);
		assertSame(ASTNode.VARIABLE_DECLARATION_FRAGMENT, 59);
		assertSame(ASTNode.VARIABLE_DECLARATION_STATEMENT, 60);
		assertSame(ASTNode.WHILE_STATEMENT, 61);
		assertSame(ASTNode.INSTANCEOF_EXPRESSION, 62);
		assertSame(ASTNode.LINE_COMMENT, 63);
		assertSame(ASTNode.BLOCK_COMMENT, 64);
		assertSame(ASTNode.TAG_ELEMENT, 65);
		assertSame(ASTNode.TEXT_ELEMENT, 66);
		assertSame(ASTNode.MEMBER_REF, 67);
		assertSame(ASTNode.METHOD_REF, 68);
		assertSame(ASTNode.METHOD_REF_PARAMETER, 69);
		assertSame(ASTNode.ENHANCED_FOR_STATEMENT, 70);
		assertSame(ASTNode.ENUM_DECLARATION, 71);
		assertSame(ASTNode.ENUM_CONSTANT_DECLARATION, 72);
		assertSame(ASTNode.TYPE_PARAMETER, 73);
		assertSame(ASTNode.PARAMETERIZED_TYPE, 74);
		assertSame(ASTNode.QUALIFIED_TYPE, 75);
		assertSame(ASTNode.WILDCARD_TYPE, 76);
		assertSame(ASTNode.NORMAL_ANNOTATION, 77);
		assertSame(ASTNode.MARKER_ANNOTATION, 78);
		assertSame(ASTNode.SINGLE_MEMBER_ANNOTATION, 79);
		assertSame(ASTNode.MEMBER_VALUE_PAIR, 80);
		assertSame(ASTNode.ANNOTATION_TYPE_DECLARATION, 81);
		assertSame(ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION, 82);
		assertSame(ASTNode.MODIFIER, 83);

		// ensure that all constants are distinct, positive, and small
		// (this may seem paranoid, but this test did uncover a stupid bug!)

Lines 1-4 Link Here

(-).settings/org.eclipse.jdt.core.prefs (-2 / +2 lines)
1	#Tue Jun 23 14:52:59 IST 2009	1	#Fri Nov 28 13:48:05 CET 2008
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	org.eclipse.jdt.core.builder.cleanOutputFolder=clean	3	org.eclipse.jdt.core.builder.cleanOutputFolder=clean
4	org.eclipse.jdt.core.builder.duplicateResourceTask=warning	4	org.eclipse.jdt.core.builder.duplicateResourceTask=warning
Lines 19-25 Link Here
19	org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning	19	org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
20	org.eclipse.jdt.core.compiler.problem.assertIdentifier=warning	20	org.eclipse.jdt.core.compiler.problem.assertIdentifier=warning
21	org.eclipse.jdt.core.compiler.problem.autoboxing=ignore	21	org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
22	org.eclipse.jdt.core.compiler.problem.comparingIdentical=ignore	22	org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning
23	org.eclipse.jdt.core.compiler.problem.deadCode=warning	23	org.eclipse.jdt.core.compiler.problem.deadCode=warning
24	org.eclipse.jdt.core.compiler.problem.deprecation=warning	24	org.eclipse.jdt.core.compiler.problem.deprecation=warning
25	org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled	25	org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled

Return to bug 287772

Lines 877-880 Link Here

(-)src/org/eclipse/jdt/core/tests/junit/extension/TestCase.java (+16 lines)
877	}	877	}
878	}	878	}
879	}	879	}
		880	static public void assertSame(int expected, int actual) {
		881	assertSame(null, expected, actual);
		882	}
		883	static public void assertSame(String message, int expected, int actual) {
		884	if (expected == actual)
		885	return;
		886	failNotSame(message, expected, actual);
		887	}
		888	static public void failNotSame(String message, int expected, int actual) {
		889	StringBuffer formatted= new StringBuffer();
		890	if (message != null) {
		891	formatted.append(message).append(' ');
		892	}
		893	formatted.append("expected same:<").append(expected).append("> was not:<").append(actual).append(">");
		894	fail(String.valueOf(formatted));
		895	}
880	}	896	}

Lines 1278-1285 Link Here

(-)src/org/eclipse/jdt/core/tests/dom/ASTTest.java (-97 / +97 lines)
1278	/** @deprecated using deprecated code */	1278	/** @deprecated using deprecated code */
1279	public void testAST() {	1279	public void testAST() {
1280		1280
1281	assertTrue(AST.JLS2 == 2);	1281	assertSame(AST.JLS2, 2);
1282	assertTrue(AST.JLS3 == 3);	1282	assertSame(AST.JLS3, 3);
1283		1283
1284	AST a0 = new AST(); // deprecated, but still 2.0	1284	AST a0 = new AST(); // deprecated, but still 2.0
1285	assertTrue(a0.apiLevel() == AST.JLS2);	1285	assertTrue(a0.apiLevel() == AST.JLS2);
Lines 8350-8367 Link Here
8350	public void testModifiers() {	8350	public void testModifiers() {
8351		8351
8352	// check all modifiers match their JVM spec values	8352	// check all modifiers match their JVM spec values
8353	assertTrue(Modifier.ABSTRACT == 0x0400);	8353	assertSame(Modifier.ABSTRACT ,0x0400);
8354	assertTrue(Modifier.FINAL == 0x0010);	8354	assertSame(Modifier.FINAL ,0x0010);
8355	assertTrue(Modifier.NATIVE == 0x0100);	8355	assertSame(Modifier.NATIVE ,0x0100);
8356	assertTrue(Modifier.NONE == 0x0000);	8356	assertSame(Modifier.NONE ,0x0000);
8357	assertTrue(Modifier.PRIVATE == 0x0002);	8357	assertSame(Modifier.PRIVATE ,0x0002);
8358	assertTrue(Modifier.PROTECTED == 0x0004);	8358	assertSame(Modifier.PROTECTED ,0x0004);
8359	assertTrue(Modifier.PUBLIC == 0x0001);	8359	assertSame(Modifier.PUBLIC ,0x0001);
8360	assertTrue(Modifier.STATIC == 0x0008);	8360	assertSame(Modifier.STATIC ,0x0008);
8361	assertTrue(Modifier.STRICTFP == 0x0800);	8361	assertSame(Modifier.STRICTFP ,0x0800);
8362	assertTrue(Modifier.SYNCHRONIZED == 0x0020);	8362	assertSame(Modifier.SYNCHRONIZED ,0x0020);
8363	assertTrue(Modifier.TRANSIENT == 0x0080);	8363	assertSame(Modifier.TRANSIENT ,0x0080);
8364	assertTrue(Modifier.VOLATILE == 0x0040);	8364	assertSame(Modifier.VOLATILE ,0x0040);
8365		8365
8366	// check that all	8366	// check that all
8367	final int[] mods =	8367	final int[] mods =
Lines 8550-8638 Link Here
8550	public void testNodeTypeConstants() {	8550	public void testNodeTypeConstants() {
8551	// it would be a breaking API change to change the numeric values of	8551	// it would be a breaking API change to change the numeric values of
8552	// public static final ints	8552	// public static final ints
8553	assertTrue(ASTNode.ANONYMOUS_CLASS_DECLARATION == 1);	8553	assertSame(ASTNode.ANONYMOUS_CLASS_DECLARATION, 1);
8554	assertTrue(ASTNode.ARRAY_ACCESS == 2);	8554	assertSame(ASTNode.ARRAY_ACCESS, 2);
8555	assertTrue(ASTNode.ARRAY_CREATION == 3);	8555	assertSame(ASTNode.ARRAY_CREATION, 3);
8556	assertTrue(ASTNode.ARRAY_INITIALIZER == 4);	8556	assertSame(ASTNode.ARRAY_INITIALIZER, 4);
8557	assertTrue(ASTNode.ARRAY_TYPE == 5);	8557	assertSame(ASTNode.ARRAY_TYPE, 5);
8558	assertTrue(ASTNode.ASSERT_STATEMENT == 6);	8558	assertSame(ASTNode.ASSERT_STATEMENT, 6);
8559	assertTrue(ASTNode.ASSIGNMENT == 7);	8559	assertSame(ASTNode.ASSIGNMENT, 7);
8560	assertTrue(ASTNode.BLOCK == 8);	8560	assertSame(ASTNode.BLOCK, 8);
8561	assertTrue(ASTNode.BOOLEAN_LITERAL == 9);	8561	assertSame(ASTNode.BOOLEAN_LITERAL, 9);
8562	assertTrue(ASTNode.BREAK_STATEMENT == 10);	8562	assertSame(ASTNode.BREAK_STATEMENT, 10);
8563	assertTrue(ASTNode.CAST_EXPRESSION == 11);	8563	assertSame(ASTNode.CAST_EXPRESSION, 11);
8564	assertTrue(ASTNode.CATCH_CLAUSE == 12);	8564	assertSame(ASTNode.CATCH_CLAUSE, 12);
8565	assertTrue(ASTNode.CHARACTER_LITERAL == 13);	8565	assertSame(ASTNode.CHARACTER_LITERAL, 13);
8566	assertTrue(ASTNode.CLASS_INSTANCE_CREATION == 14);	8566	assertSame(ASTNode.CLASS_INSTANCE_CREATION, 14);
8567	assertTrue(ASTNode.COMPILATION_UNIT == 15);	8567	assertSame(ASTNode.COMPILATION_UNIT, 15);
8568	assertTrue(ASTNode.CONDITIONAL_EXPRESSION == 16);	8568	assertSame(ASTNode.CONDITIONAL_EXPRESSION, 16);
8569	assertTrue(ASTNode.CONSTRUCTOR_INVOCATION == 17);	8569	assertSame(ASTNode.CONSTRUCTOR_INVOCATION, 17);
8570	assertTrue(ASTNode.CONTINUE_STATEMENT == 18);	8570	assertSame(ASTNode.CONTINUE_STATEMENT, 18);
8571	assertTrue(ASTNode.DO_STATEMENT == 19);	8571	assertSame(ASTNode.DO_STATEMENT, 19);
8572	assertTrue(ASTNode.EMPTY_STATEMENT == 20);	8572	assertSame(ASTNode.EMPTY_STATEMENT, 20);
8573	assertTrue(ASTNode.EXPRESSION_STATEMENT == 21);	8573	assertSame(ASTNode.EXPRESSION_STATEMENT, 21);
8574	assertTrue(ASTNode.FIELD_ACCESS == 22);	8574	assertSame(ASTNode.FIELD_ACCESS, 22);
8575	assertTrue(ASTNode.FIELD_DECLARATION == 23);	8575	assertSame(ASTNode.FIELD_DECLARATION, 23);
8576	assertTrue(ASTNode.FOR_STATEMENT == 24);	8576	assertSame(ASTNode.FOR_STATEMENT, 24);
8577	assertTrue(ASTNode.IF_STATEMENT == 25);	8577	assertSame(ASTNode.IF_STATEMENT, 25);
8578	assertTrue(ASTNode.IMPORT_DECLARATION == 26);	8578	assertSame(ASTNode.IMPORT_DECLARATION, 26);
8579	assertTrue(ASTNode.INFIX_EXPRESSION == 27);	8579	assertSame(ASTNode.INFIX_EXPRESSION, 27);
8580	assertTrue(ASTNode.INITIALIZER == 28);	8580	assertSame(ASTNode.INITIALIZER, 28);
8581	assertTrue(ASTNode.JAVADOC == 29);	8581	assertSame(ASTNode.JAVADOC, 29);
8582	assertTrue(ASTNode.LABELED_STATEMENT == 30);	8582	assertSame(ASTNode.LABELED_STATEMENT, 30);
8583	assertTrue(ASTNode.METHOD_DECLARATION == 31);	8583	assertSame(ASTNode.METHOD_DECLARATION, 31);
8584	assertTrue(ASTNode.METHOD_INVOCATION == 32);	8584	assertSame(ASTNode.METHOD_INVOCATION, 32);
8585	assertTrue(ASTNode.NULL_LITERAL == 33);	8585	assertSame(ASTNode.NULL_LITERAL, 33);
8586	assertTrue(ASTNode.NUMBER_LITERAL == 34);	8586	assertSame(ASTNode.NUMBER_LITERAL, 34);
8587	assertTrue(ASTNode.PACKAGE_DECLARATION == 35);	8587	assertSame(ASTNode.PACKAGE_DECLARATION, 35);
8588	assertTrue(ASTNode.PARENTHESIZED_EXPRESSION == 36);	8588	assertSame(ASTNode.PARENTHESIZED_EXPRESSION, 36);
8589	assertTrue(ASTNode.POSTFIX_EXPRESSION == 37);	8589	assertSame(ASTNode.POSTFIX_EXPRESSION, 37);
8590	assertTrue(ASTNode.PREFIX_EXPRESSION == 38);	8590	assertSame(ASTNode.PREFIX_EXPRESSION, 38);
8591	assertTrue(ASTNode.PRIMITIVE_TYPE == 39);	8591	assertSame(ASTNode.PRIMITIVE_TYPE, 39);
8592	assertTrue(ASTNode.QUALIFIED_NAME == 40);	8592	assertSame(ASTNode.QUALIFIED_NAME, 40);
8593	assertTrue(ASTNode.RETURN_STATEMENT == 41);	8593	assertSame(ASTNode.RETURN_STATEMENT, 41);
8594	assertTrue(ASTNode.SIMPLE_NAME == 42);	8594	assertSame(ASTNode.SIMPLE_NAME, 42);
8595	assertTrue(ASTNode.SIMPLE_TYPE == 43);	8595	assertSame(ASTNode.SIMPLE_TYPE, 43);
8596	assertTrue(ASTNode.SINGLE_VARIABLE_DECLARATION == 44);	8596	assertSame(ASTNode.SINGLE_VARIABLE_DECLARATION, 44);
8597	assertTrue(ASTNode.STRING_LITERAL == 45);	8597	assertSame(ASTNode.STRING_LITERAL, 45);
8598	assertTrue(ASTNode.SUPER_CONSTRUCTOR_INVOCATION == 46);	8598	assertSame(ASTNode.SUPER_CONSTRUCTOR_INVOCATION, 46);
8599	assertTrue(ASTNode.SUPER_FIELD_ACCESS == 47);	8599	assertSame(ASTNode.SUPER_FIELD_ACCESS, 47);
8600	assertTrue(ASTNode.SUPER_METHOD_INVOCATION == 48);	8600	assertSame(ASTNode.SUPER_METHOD_INVOCATION, 48);
8601	assertTrue(ASTNode.SWITCH_CASE == 49);	8601	assertSame(ASTNode.SWITCH_CASE, 49);
8602	assertTrue(ASTNode.SWITCH_STATEMENT == 50);	8602	assertSame(ASTNode.SWITCH_STATEMENT, 50);
8603	assertTrue(ASTNode.SYNCHRONIZED_STATEMENT == 51);	8603	assertSame(ASTNode.SYNCHRONIZED_STATEMENT, 51);
8604	assertTrue(ASTNode.THIS_EXPRESSION == 52);	8604	assertSame(ASTNode.THIS_EXPRESSION, 52);
8605	assertTrue(ASTNode.THROW_STATEMENT == 53);	8605	assertSame(ASTNode.THROW_STATEMENT, 53);
8606	assertTrue(ASTNode.TRY_STATEMENT == 54);	8606	assertSame(ASTNode.TRY_STATEMENT, 54);
8607	assertTrue(ASTNode.TYPE_DECLARATION == 55);	8607	assertSame(ASTNode.TYPE_DECLARATION, 55);
8608	assertTrue(ASTNode.TYPE_DECLARATION_STATEMENT == 56);	8608	assertSame(ASTNode.TYPE_DECLARATION_STATEMENT, 56);
8609	assertTrue(ASTNode.TYPE_LITERAL == 57);	8609	assertSame(ASTNode.TYPE_LITERAL, 57);
8610	assertTrue(ASTNode.VARIABLE_DECLARATION_EXPRESSION == 58);	8610	assertSame(ASTNode.VARIABLE_DECLARATION_EXPRESSION, 58);
8611	assertTrue(ASTNode.VARIABLE_DECLARATION_FRAGMENT == 59);	8611	assertSame(ASTNode.VARIABLE_DECLARATION_FRAGMENT, 59);
8612	assertTrue(ASTNode.VARIABLE_DECLARATION_STATEMENT == 60);	8612	assertSame(ASTNode.VARIABLE_DECLARATION_STATEMENT, 60);
8613	assertTrue(ASTNode.WHILE_STATEMENT == 61);	8613	assertSame(ASTNode.WHILE_STATEMENT, 61);
8614	assertTrue(ASTNode.INSTANCEOF_EXPRESSION == 62);	8614	assertSame(ASTNode.INSTANCEOF_EXPRESSION, 62);
8615	assertTrue(ASTNode.LINE_COMMENT == 63);	8615	assertSame(ASTNode.LINE_COMMENT, 63);
8616	assertTrue(ASTNode.BLOCK_COMMENT == 64);	8616	assertSame(ASTNode.BLOCK_COMMENT, 64);
8617	assertTrue(ASTNode.TAG_ELEMENT == 65);	8617	assertSame(ASTNode.TAG_ELEMENT, 65);
8618	assertTrue(ASTNode.TEXT_ELEMENT == 66);	8618	assertSame(ASTNode.TEXT_ELEMENT, 66);
8619	assertTrue(ASTNode.MEMBER_REF == 67);	8619	assertSame(ASTNode.MEMBER_REF, 67);
8620	assertTrue(ASTNode.METHOD_REF == 68);	8620	assertSame(ASTNode.METHOD_REF, 68);
8621	assertTrue(ASTNode.METHOD_REF_PARAMETER == 69);	8621	assertSame(ASTNode.METHOD_REF_PARAMETER, 69);
8622	assertTrue(ASTNode.ENHANCED_FOR_STATEMENT == 70);	8622	assertSame(ASTNode.ENHANCED_FOR_STATEMENT, 70);
8623	assertTrue(ASTNode.ENUM_DECLARATION == 71);	8623	assertSame(ASTNode.ENUM_DECLARATION, 71);
8624	assertTrue(ASTNode.ENUM_CONSTANT_DECLARATION == 72);	8624	assertSame(ASTNode.ENUM_CONSTANT_DECLARATION, 72);
8625	assertTrue(ASTNode.TYPE_PARAMETER == 73);	8625	assertSame(ASTNode.TYPE_PARAMETER, 73);
8626	assertTrue(ASTNode.PARAMETERIZED_TYPE == 74);	8626	assertSame(ASTNode.PARAMETERIZED_TYPE, 74);
8627	assertTrue(ASTNode.QUALIFIED_TYPE == 75);	8627	assertSame(ASTNode.QUALIFIED_TYPE, 75);
8628	assertTrue(ASTNode.WILDCARD_TYPE == 76);	8628	assertSame(ASTNode.WILDCARD_TYPE, 76);
8629	assertTrue(ASTNode.NORMAL_ANNOTATION == 77);	8629	assertSame(ASTNode.NORMAL_ANNOTATION, 77);
8630	assertTrue(ASTNode.MARKER_ANNOTATION == 78);	8630	assertSame(ASTNode.MARKER_ANNOTATION, 78);
8631	assertTrue(ASTNode.SINGLE_MEMBER_ANNOTATION == 79);	8631	assertSame(ASTNode.SINGLE_MEMBER_ANNOTATION, 79);
8632	assertTrue(ASTNode.MEMBER_VALUE_PAIR == 80);	8632	assertSame(ASTNode.MEMBER_VALUE_PAIR, 80);
8633	assertTrue(ASTNode.ANNOTATION_TYPE_DECLARATION == 81);	8633	assertSame(ASTNode.ANNOTATION_TYPE_DECLARATION, 81);
8634	assertTrue(ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION == 82);	8634	assertSame(ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION, 82);
8635	assertTrue(ASTNode.MODIFIER == 83);	8635	assertSame(ASTNode.MODIFIER, 83);
8636		8636
8637	// ensure that all constants are distinct, positive, and small	8637	// ensure that all constants are distinct, positive, and small
8638	// (this may seem paranoid, but this test did uncover a stupid bug!)	8638	// (this may seem paranoid, but this test did uncover a stupid bug!)