Attachment 4578 Details for Bug 36144 – DOM/AST API experimental support for JSR-201 - API test suites

[patch] DOM/AST API experimental support for JSR-201 - API test suites

ast-JSR-201-tests-patch-20030408.txt (text/plain), 14.76 KB, created by Jim des Rivieres

on 2003-04-14 13:24:25 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Jim des Rivieres

Created: 2003-04-14 13:24:25 EDT

Size: 14.76 KB

patch

obsolete

>Index: src/org/eclipse/jdt/core/tests/dom/ASTMatcherTest.java
>===================================================================
>RCS file: /data/cvs/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTMatcherTest.java,v
>retrieving revision 1.6
>diff -u -r1.6 ASTMatcherTest.java
>--- src/org/eclipse/jdt/core/tests/dom/ASTMatcherTest.java	11 Mar 2003 15:07:11 -0000	1.6
>+++ src/org/eclipse/jdt/core/tests/dom/ASTMatcherTest.java	8 Apr 2003 16:49:05 -0000
>@@ -259,6 +259,12 @@
> 		public boolean match(EmptyStatement node, Object other) {
> 			return standardBody(node, other, superMatch ? super.match(node, other) : false);
> 		}
>+		public boolean match(EnhancedForStatement node, Object other) {
>+			return standardBody(node, other, superMatch ? super.match(node, other) : false);
>+		}
>+		public boolean match(EnumConstantDeclaration node, Object other) {
>+			return standardBody(node, other, superMatch ? super.match(node, other) : false);
>+		}
> 		public boolean match(ExpressionStatement node, Object other) {
> 			return standardBody(node, other, superMatch ? super.match(node, other) : false);
> 		}
>@@ -592,6 +598,24 @@
> 	}
> 	public void testEmptyStatement() {
> 		EmptyStatement x1 = ast.newEmptyStatement();
>+		basicMatch(x1);
>+	}
>+	public void testEnhancedForStatement() {
>+		EnhancedForStatement x1 = ast.newEnhancedForStatement();
>+		x1.setType(T1);
>+		x1.setName(N1);
>+		x1.setExpression(E1);
>+		x1.setBody(S1);
>+		basicMatch(x1);
>+	}
>+	public void testEnumConstantDeclaration() {
>+		EnumConstantDeclaration x1 = ast.newEnumConstantDeclaration();
>+		x1.setJavadoc(JD1);
>+		x1.setName(N1);
>+		x1.arguments().add(E1);
>+		x1.arguments().add(E2);
>+		x1.bodyDeclarations().add(FD1);
>+		x1.bodyDeclarations().add(FD2);
> 		basicMatch(x1);
> 	}
> 	public void testExpressionStatement() {
>Index: src/org/eclipse/jdt/core/tests/dom/ASTTest.java
>===================================================================
>RCS file: /data/cvs/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTTest.java,v
>retrieving revision 1.15
>diff -u -r1.15 ASTTest.java
>--- src/org/eclipse/jdt/core/tests/dom/ASTTest.java	11 Mar 2003 15:07:11 -0000	1.15
>+++ src/org/eclipse/jdt/core/tests/dom/ASTTest.java	8 Apr 2003 16:49:09 -0000
>@@ -1663,6 +1663,7 @@
> 		assertTrue(x.getAST() == ast);
> 		assertTrue(x.getParent() == null);
> 		assertTrue(x.isOnDemand() == false);
>+		assertTrue(x.isStatic() == false);
> 		assertTrue(x.getName().getParent() == x);
> 		assertTrue(x.getNodeType() == ASTNode.IMPORT_DECLARATION);
> 		// make sure that reading did not change modification count
>@@ -1692,6 +1693,9 @@
> 		x.setOnDemand(true);
> 		assertTrue(ast.modificationCount() > previousCount);
> 		assertTrue(x.isOnDemand() == true);
>+		x.setStatic(true);
>+		assertTrue(ast.modificationCount() > previousCount);
>+		assertTrue(x.isStatic() == true);
> 	}
> 	
> 	public void testCompilationUnit() {
>@@ -1825,6 +1829,7 @@
> 		assertTrue(x.getParent() == null);
> 		assertTrue(x.getModifiers() == Modifier.NONE);
> 		assertTrue(x.isInterface() == false);
>+		assertTrue(x.isEnumeration() == false);
> 		assertTrue(x.getName().getParent() == x);
> 		assertTrue(x.getName().isDeclaration() == true);
> 		assertTrue(x.getSuperclass() == null);
>@@ -1853,6 +1858,12 @@
> 		assertTrue(ast.modificationCount() > previousCount);
> 		assertTrue(x.getModifiers() == Modifier.NONE);
> 
>+		previousCount = ast.modificationCount();
>+		x.setEnumeration(true);	
>+		assertTrue(ast.modificationCount() > previousCount);
>+		assertTrue(x.isEnumeration() == true);
>+		x.setEnumeration(false);	
>+		
> 		tJavadocComment(x);
> 				
> 		genericPropertyTest(x, new Property("Name", true, SimpleName.class) { //$NON-NLS-1$
>@@ -1927,7 +1938,11 @@
> 		MethodDeclaration m2 = ast.newMethodDeclaration();
> 		TypeDeclaration t1 = ast.newTypeDeclaration();
> 		TypeDeclaration t2 = ast.newTypeDeclaration();
>+		EnumConstantDeclaration c1 = ast.newEnumConstantDeclaration();
>+		EnumConstantDeclaration c2 = ast.newEnumConstantDeclaration();
> 
>+		x.bodyDeclarations().add(c1);
>+		x.bodyDeclarations().add(c2);
> 		x.bodyDeclarations().add(ast.newInitializer());
> 		x.bodyDeclarations().add(f1);
> 		x.bodyDeclarations().add(ast.newInitializer());
>@@ -1957,7 +1972,99 @@
> 		assertTrue(ts.contains(t1));
> 		assertTrue(ts.contains(t2));
> 		
>+		List es = Arrays.asList(x.getEnumConstants());
>+		assertTrue(es.size() == 2);
>+		assertTrue(es.contains(c1));
>+		assertTrue(es.contains(c2));
>+		
>+		// check that TypeDeclarations in body are classified correctly
>+		assertTrue(t1.isLocalTypeDeclaration() == false);
>+		assertTrue(t1.isMemberTypeDeclaration() == true);
>+		assertTrue(t1.isPackageMemberTypeDeclaration() == false);
>+	
>+	}	
>+	
>+	public void testEnumConstantDeclaration() {
>+		long previousCount = ast.modificationCount();
>+		final EnumConstantDeclaration x = ast.newEnumConstantDeclaration();
>+		assertTrue(ast.modificationCount() > previousCount);
>+		previousCount = ast.modificationCount();
>+		assertTrue(x instanceof BodyDeclaration);
>+		assertTrue(x.getAST() == ast);
>+		assertTrue(x.getParent() == null);
>+		assertTrue(x.getName().getParent() == x);
>+		assertTrue(x.getName().isDeclaration() == true);
>+		assertTrue(x.getJavadoc() == null);
>+		assertTrue(x.arguments().size()== 0);
>+		assertTrue(x.bodyDeclarations().size()== 0);
>+		assertTrue(x.getNodeType() == ASTNode.ENUM_CONSTANT_DECLARATION);
>+		// make sure that reading did not change modification count
>+		assertTrue(ast.modificationCount() == previousCount);
>+			
>+		tJavadocComment(x);
>+				
>+		genericPropertyTest(x, new Property("Name", true, SimpleName.class) { //$NON-NLS-1$
>+			public ASTNode sample(AST targetAst, boolean parented) {
>+				SimpleName result = targetAst.newSimpleName("foo"); //$NON-NLS-1$
>+				if (parented) {
>+					targetAst.newExpressionStatement(result);
>+				}
>+				return result;
>+			}
>+			public ASTNode get() {
>+				return x.getName();
>+			}
>+			public void set(ASTNode value) {
>+				x.setName((SimpleName) value);
>+			}
>+		});
>+				
>+		genericPropertyListTest(x, x.arguments(),
>+		  new Property("Arguments", true, Expression.class) { //$NON-NLS-1$
>+			public ASTNode sample(AST targetAst, boolean parented) {
>+				SimpleName result = targetAst.newSimpleName("foo"); //$NON-NLS-1$
>+				if (parented) {
>+					targetAst.newExpressionStatement(result);
>+				}
>+				return result;
>+			}
>+			public ASTNode wrap() {
>+				AnonymousClassDeclaration s1 = x.getAST().newAnonymousClassDeclaration();
>+				s1.bodyDeclarations().add(x);
>+				return s1;
>+			}
>+			public void unwrap() {
>+				AnonymousClassDeclaration s1 = (AnonymousClassDeclaration) x.getParent();
>+				s1.bodyDeclarations().remove(x);
>+			}
>+		});
>+
>+		genericPropertyListTest(x, x.bodyDeclarations(),
>+		  new Property("BodyDeclarations", true, BodyDeclaration.class) { //$NON-NLS-1$
>+			public ASTNode sample(AST targetAst, boolean parented) {
>+				TypeDeclaration result = targetAst.newTypeDeclaration();
>+				if (parented) {
>+					CompilationUnit cu = targetAst.newCompilationUnit();
>+					cu.types().add(result);
>+				}
>+				return result;
>+			}
>+			public ASTNode wrap() {
>+				EnumConstantDeclaration s1 = x.getAST().newEnumConstantDeclaration();
>+				s1.bodyDeclarations().add(x);
>+				return s1;
>+			}
>+			public void unwrap() {
>+				EnumConstantDeclaration s1 = (EnumConstantDeclaration) x.getParent();
>+				s1.bodyDeclarations().remove(x);
>+			}
>+		});
>+		
> 		// check that TypeDeclarations in body are classified correctly
>+		x.bodyDeclarations().clear();
>+		TypeDeclaration t1 = ast.newTypeDeclaration();
>+		x.bodyDeclarations().add(t1);
>+
> 		assertTrue(t1.isLocalTypeDeclaration() == false);
> 		assertTrue(t1.isMemberTypeDeclaration() == true);
> 		assertTrue(t1.isPackageMemberTypeDeclaration() == false);
>@@ -4357,6 +4464,11 @@
> 		VariableDeclarationExpression variableDeclarationExpression = target.newVariableDeclarationExpression(variableDeclarationFragment3);
> 		variableDeclarationExpression.setSourceRange(430, 5);
> 		z.add(variableDeclarationExpression);
>+		
>+		// new for 2.2
>+		EnhancedForStatement foreachStatement = target.newEnhancedForStatement();
>+		foreachStatement.setSourceRange(500, 5);
>+		b.statements().add(foreachStatement);
> 
> 		ASTNode clone = ASTNode.copySubtree(ast, cu);
> 		assertTrue(cu.subtreeMatch(new CheckPositionsMatcher(), clone));
>@@ -4570,6 +4682,124 @@
> 			public void unwrap() {
> 				Block s3 = (Block) x.getParent();
> 				s3.statements().remove(x);
>+			}
>+		});
>+
>+		genericPropertyTest(x, new Property("Body", true, Statement.class) { //$NON-NLS-1$
>+			public ASTNode sample(AST targetAst, boolean parented) {
>+				Block result = targetAst.newBlock();
>+				if (parented) {
>+					Block b2 = targetAst.newBlock();
>+					b2.statements().add(result);
>+				}
>+				return result;
>+			}
>+			public ASTNode wrap() {
>+				// return a Statement that embeds x
>+				Block s1 = ast.newBlock();
>+				s1.statements().add(x);
>+				return s1;
>+			}
>+			public void unwrap() {
>+				Block s2 = (Block) x.getParent();
>+				s2.statements().remove(x);
>+			}
>+			public ASTNode get() {
>+				return x.getBody();
>+			}
>+			public void set(ASTNode value) {
>+				x.setBody((Statement) value);
>+			}
>+		});
>+	}
>+
>+	public void testEnhancedForStatement() {
>+		long previousCount = ast.modificationCount();
>+		final EnhancedForStatement x = ast.newEnhancedForStatement();
>+		assertTrue(ast.modificationCount() > previousCount);
>+		previousCount = ast.modificationCount();
>+		assertTrue(x instanceof Statement);
>+		assertTrue(x.getAST() == ast);
>+		assertTrue(x.getParent() == null);
>+		assertTrue(x.getType() != null);
>+		assertTrue(x.getType().getParent() == x);
>+		assertTrue(x.getName() != null);
>+		assertTrue(x.getName().getParent() == x);
>+		assertTrue(x.getName().isDeclaration() == true);
>+		assertTrue(x.getExpression() != null);
>+		assertTrue(x.getExpression().getParent() == x);
>+		assertTrue(x.getBody().getParent() == x);
>+		assertTrue(x.getBody() instanceof Block);
>+		assertTrue(((Block) x.getBody()).statements().isEmpty());
>+		assertTrue(x.getLeadingComment() == null);
>+		assertTrue(x.getNodeType() == ASTNode.ENHANCED_FOR_STATEMENT);
>+		// make sure that reading did not change modification count
>+		assertTrue(ast.modificationCount() == previousCount);
>+
>+		tLeadingComment(x);
>+		
>+		genericPropertyTest(x, new Property("Type", true, Type.class) { //$NON-NLS-1$
>+			public ASTNode sample(AST targetAst, boolean parented) {
>+				SimpleType result = targetAst.newSimpleType(
>+					targetAst.newSimpleName("a")); //$NON-NLS-1$
>+				if (parented) {
>+					targetAst.newArrayType(result);
>+				}
>+				return result;
>+			}
>+			public ASTNode get() {
>+				return x.getType();
>+			}
>+			public void set(ASTNode value) {
>+				x.setType((Type) value);
>+			}
>+		});
>+		
>+		genericPropertyTest(x, new Property("Name", true, SimpleName.class) { //$NON-NLS-1$
>+			public ASTNode sample(AST targetAst, boolean parented) {
>+				SimpleName result = targetAst.newSimpleName("foo"); //$NON-NLS-1$
>+				if (parented) {
>+					targetAst.newExpressionStatement(result);
>+				}
>+				return result;
>+			}
>+			public ASTNode get() {
>+				return x.getName();
>+			}
>+			public void set(ASTNode value) {
>+				x.setName((SimpleName) value);
>+			}
>+		});
>+		
>+		genericPropertyTest(x, new Property("Expression", true, Expression.class) { //$NON-NLS-1$
>+			public ASTNode sample(AST ast, boolean parented) {
>+				Expression result = ast.newSimpleName("foo"); //$NON-NLS-1$
>+				if (parented) {
>+					ast.newExpressionStatement(result);
>+				}
>+				return result;
>+			}
>+			public ASTNode wrap() {
>+				// return Expression that embeds x
>+				ClassInstanceCreation s1 = ast.newClassInstanceCreation();
>+				AnonymousClassDeclaration a1 = ast.newAnonymousClassDeclaration();
>+				s1.setAnonymousClassDeclaration(a1);
>+				MethodDeclaration s2 = ast.newMethodDeclaration();
>+				a1.bodyDeclarations().add(s2);
>+				Block s3 = ast.newBlock();
>+				s2.setBody(s3);
>+				s3.statements().add(x);
>+				return s1;
>+			}
>+			public void unwrap() {
>+				Block s3 = (Block) x.getParent();
>+				s3.statements().remove(x);
>+			}
>+			public ASTNode get() {
>+				return x.getExpression();
>+			}
>+			public void set(ASTNode value) {
>+				x.setExpression((Expression) value);
> 			}
> 		});
> 
>Index: src/org/eclipse/jdt/core/tests/dom/ASTVisitorTest.java
>===================================================================
>RCS file: /data/cvs/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/dom/ASTVisitorTest.java,v
>retrieving revision 1.8
>diff -u -r1.8 ASTVisitorTest.java
>--- src/org/eclipse/jdt/core/tests/dom/ASTVisitorTest.java	11 Mar 2003 15:07:11 -0000	1.8
>+++ src/org/eclipse/jdt/core/tests/dom/ASTVisitorTest.java	8 Apr 2003 16:49:10 -0000
>@@ -383,6 +383,22 @@
> 			b.append("sEM)"); //$NON-NLS-1$
> 		}
> 
>+		public boolean visit(EnhancedForStatement node) {
>+			b.append("(sEFR"); //$NON-NLS-1$
>+			return isVisitingChildren();
>+		}
>+		public void endVisit(EnhancedForStatement node) {
>+			b.append("sEFR)"); //$NON-NLS-1$
>+		}
>+
>+		public boolean visit(EnumConstantDeclaration node) {
>+			b.append("(ECD"); //$NON-NLS-1$
>+			return isVisitingChildren();
>+		}
>+		public void endVisit(EnumConstantDeclaration node) {
>+			b.append("ECD)"); //$NON-NLS-1$
>+		}
>+
> 		public boolean visit(ExpressionStatement node) {
> 			b.append("(sEX"); //$NON-NLS-1$
> 			return isVisitingChildren();
>@@ -964,6 +980,20 @@
> 		String result = b.toString();
> 		assertTrue(result.equals("[(sEMsEM)]")); //$NON-NLS-1$
> 	}
>+	public void testEnumConstantDeclaration() {
>+		EnumConstantDeclaration x1 = ast.newEnumConstantDeclaration();
>+		x1.setJavadoc(JD1);
>+		x1.setName(N1);
>+		x1.arguments().add(E1);
>+		x1.arguments().add(E2);
>+		x1.bodyDeclarations().add(FD1);
>+		x1.bodyDeclarations().add(FD2);
>+		TestVisitor v1 = new TestVisitor();
>+		b.setLength(0);
>+		x1.accept(v1);
>+		String result = b.toString();
>+		assertTrue(result.equals("[(ECD"+JD1S+N1S+E1S+E2S+FD1S+FD2S+"ECD)]")); //$NON-NLS-1$ //$NON-NLS-2$
>+	}
> 	public void testExpressionStatement() {
> 		ExpressionStatement x1 = ast.newExpressionStatement(E1);
> 		TestVisitor v1 = new TestVisitor();
>@@ -1006,6 +1036,18 @@
> 		x1.accept(v1);
> 		String result = b.toString();
> 		assertTrue(result.equals("[(sFR"+E1S+E2S+N1S+N2S+N3S+S1S+"sFR)]")); //$NON-NLS-1$ //$NON-NLS-2$
>+	}
>+	public void testEnhancedForStatement() {
>+		EnhancedForStatement x1 = ast.newEnhancedForStatement();
>+		x1.setType(T1);
>+		x1.setName(N1);
>+		x1.setExpression(E1);
>+		x1.setBody(S1);
>+		TestVisitor v1 = new TestVisitor();
>+		b.setLength(0);
>+		x1.accept(v1);
>+		String result = b.toString();
>+		assertTrue(result.equals("[(sEFR"+T1S+N1S+E1S+S1S+"sEFR)]")); //$NON-NLS-1$ //$NON-NLS-2$
> 	}
> 	public void testIfStatement() {
> 		IfStatement x1 = ast.newIfStatement();

Actions: View | Diff

Attachments on bug 36144: 4577 | 4578