1   /***
2    * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3   */
4   package test.net.sourceforge.pmd.jaxen;
5   
6   import net.sourceforge.pmd.AbstractRule;
7   import net.sourceforge.pmd.Report;
8   import net.sourceforge.pmd.ast.ASTCompilationUnit;
9   import net.sourceforge.pmd.ast.ASTImportDeclaration;
10  import net.sourceforge.pmd.ast.ASTMethodDeclaration;
11  import net.sourceforge.pmd.ast.ASTPrimaryExpression;
12  import net.sourceforge.pmd.ast.ASTPrimaryPrefix;
13  import net.sourceforge.pmd.ast.ASTStatement;
14  import net.sourceforge.pmd.ast.ASTTypeDeclaration;
15  import net.sourceforge.pmd.ast.Node;
16  import net.sourceforge.pmd.jaxen.DocumentNavigator;
17  import org.jaxen.BaseXPath;
18  import org.jaxen.JaxenException;
19  import org.jaxen.UnsupportedAxisException;
20  import test.net.sourceforge.pmd.rules.EmptyCatchBlockRuleTest;
21  import test.net.sourceforge.pmd.testframework.RuleTst;
22  
23  import java.util.Iterator;
24  import java.util.List;
25  
26  public class DocumentNavigatorTest extends RuleTst {
27  
28     
29      private TestRule rule;
30  
31      private class TestRule extends AbstractRule {
32  		
33          private Node compilationUnit;
34          private Node importDeclaration;
35          private Node typeDeclaration;
36          private Node statement;
37          private Node primaryPrefix;
38          private Node primaryExpression;
39          private Node methodDeclaration;
40          /***
41           * @see net.sourceforge.pmd.ast.JavaParserVisitor#visit(ASTCompilationUnit, Object)
42           */
43          public Object visit(ASTCompilationUnit node, Object data) {
44              this.compilationUnit = node;
45              return super.visit(node, data);
46          }
47          public Object visit(ASTImportDeclaration node, Object data) {
48              this.importDeclaration = node;
49              return super.visit(node, data);
50          }
51          public Object visit(ASTTypeDeclaration node, Object data) {
52              this.typeDeclaration = node;
53              return super.visit(node, data);
54          }
55          public Object visit(ASTStatement node, Object data) {
56              this.statement = node;
57              return super.visit(node, data);
58          }
59          public Object visit(ASTPrimaryPrefix node, Object data) {
60              this.primaryPrefix = node;
61              return super.visit(node, data);
62          }
63          public Object visit(ASTMethodDeclaration node, Object data) {
64              this.methodDeclaration = node;
65              return super.visit(node, data);
66          }
67          public Object visit(ASTPrimaryExpression node, Object data) {
68              this.primaryExpression = node;
69              return super.visit(node, data);
70          }
71      }
72  
73      public void setUp() throws Exception {
74          try{
75              rule = new TestRule();
76              runTestFromString(EmptyCatchBlockRuleTest.TEST1, rule, new Report());
77          } catch (Throwable xx) {
78              fail();
79          }
80      }
81      
82      public void testChildAxisIterator() {
83          DocumentNavigator nav = new DocumentNavigator();
84          Iterator iter =nav.getChildAxisIterator(rule.compilationUnit);
85          assertSame(rule.compilationUnit.jjtGetChild(0), iter.next());
86          assertSame(rule.compilationUnit.jjtGetChild(1), iter.next());
87          assertFalse(iter.hasNext());
88      }
89  
90      public void testParentAxisIterator() {
91          DocumentNavigator nav = new DocumentNavigator();
92          Iterator iter =nav.getParentAxisIterator(rule.importDeclaration);
93          assertSame(rule.importDeclaration.jjtGetParent(), iter.next());
94          assertFalse(iter.hasNext());
95      }
96      
97      public void testParentAxisIterator2() {
98          DocumentNavigator nav = new DocumentNavigator();
99          Iterator iter =nav.getParentAxisIterator(rule.compilationUnit);
100         assertFalse(iter.hasNext());
101     }
102 
103     public void testDescendantAxisIterator() throws UnsupportedAxisException {
104         DocumentNavigator nav = new DocumentNavigator();
105 		Iterator iter = nav.getDescendantAxisIterator(rule.statement);
106 		Node statementExpression = rule.statement.jjtGetChild(0);
107 		assertSame(statementExpression, iter.next());
108 		Node primaryExpression = statementExpression.jjtGetChild(0);
109         assertSame(primaryExpression, iter.next());
110         Node primaryPrefix = primaryExpression.jjtGetChild(0);
111         assertSame(primaryPrefix, iter.next());
112         Node primarySuffix = primaryExpression.jjtGetChild(1);
113         assertSame(primarySuffix, iter.next());
114         Node name = primaryPrefix.jjtGetChild(0);
115         assertSame(name, iter.next());
116         Node arguments = primarySuffix.jjtGetChild(0);
117         assertSame(arguments, iter.next());
118         assertFalse(iter.hasNext());
119     }
120     
121     public void testDescendantAxisIterator2() throws UnsupportedAxisException {
122         DocumentNavigator nav = new DocumentNavigator();
123         Iterator iter = nav.getDescendantAxisIterator(rule.primaryPrefix);
124         Node name = rule.primaryPrefix.jjtGetChild(0);
125         assertSame(name, iter.next());
126         assertFalse(iter.hasNext());
127     }
128     
129     public void testFollowingSiblingAxisIterator() {
130         DocumentNavigator nav = new DocumentNavigator();
131         Iterator iter = nav.getFollowingSiblingAxisIterator(rule.primaryExpression.jjtGetChild(0));
132         assertSame(rule.primaryExpression.jjtGetChild(1), iter.next());
133         assertFalse(iter.hasNext());
134     }
135 
136     public void testFollowingSiblingAxisIterator2() {
137         DocumentNavigator nav = new DocumentNavigator();
138         Iterator iter = nav.getFollowingSiblingAxisIterator(rule.primaryExpression.jjtGetChild(1));
139         assertFalse(iter.hasNext());
140     }
141 
142     public void testPrecedingSiblingAxisIterator() {
143         DocumentNavigator nav = new DocumentNavigator();
144         Iterator iter = nav.getPrecedingSiblingAxisIterator(rule.primaryExpression.jjtGetChild(1));
145         assertSame(rule.primaryExpression.jjtGetChild(0), iter.next());
146         assertFalse(iter.hasNext());
147     }
148 
149     public void testPrecedingSiblingAxisIterator2() {
150         DocumentNavigator nav = new DocumentNavigator();
151         Iterator iter = nav.getPrecedingSiblingAxisIterator(rule.primaryExpression.jjtGetChild(0));
152         assertFalse(iter.hasNext());
153     }
154 
155     public void testXPath() throws JaxenException {
156 		BaseXPath xPath = new BaseXPath(".//*", new DocumentNavigator());
157 		List matches = xPath.selectNodes(rule.statement);
158 		assertEquals(6, matches.size());
159     }
160 
161     public void testXPath2() throws JaxenException {
162         BaseXPath xPath = new BaseXPath(".//*", new DocumentNavigator());
163         List matches = xPath.selectNodes(rule.importDeclaration);
164         assertEquals(1, matches.size());        
165     }
166 }