View Javadoc
1   /**
2    * BSD-style license; for more info see http://pmd.sourceforge.net/license.html
3    */
4   package net.sourceforge.pmd.lang.java.symboltable;
5   
6   import static org.junit.Assert.assertEquals;
7   import net.sourceforge.pmd.PMD;
8   import net.sourceforge.pmd.lang.java.symboltable.TypeSet;
9   import net.sourceforge.pmd.lang.java.typeresolution.PMDASMClassLoader;
10  
11  import org.junit.Test;
12  
13  import java.io.File;
14  import java.util.HashSet;
15  import java.util.Set;
16  
17  public class TypeSetTest {
18      private PMDASMClassLoader pmdClassLoader = PMDASMClassLoader.getInstance(TypeSetTest.class.getClassLoader());
19  
20      @Test
21      public void testASTCompilationUnitPackage() {
22          TypeSet t = new TypeSet();
23          t.setASTCompilationUnitPackage("java.lang.");
24          assertEquals("java.lang.", t.getASTCompilationUnitPackage());
25      }
26  
27      @Test
28      public void testAddImport() {
29          TypeSet t = new TypeSet();
30          t.addImport("java.io.File");
31          assertEquals(1, t.getImportsCount());
32      }
33  
34      @Test
35      public void testFindClassImplicitImport() throws Throwable {
36          TypeSet t = new TypeSet();
37          Class clazz = t.findClass("String");
38          assertEquals(String.class, clazz);
39      }
40  
41      @Test
42      public void testFindClassSamePackage() throws Throwable {
43          TypeSet t = new TypeSet();
44          t.setASTCompilationUnitPackage("net.sourceforge.pmd");
45          Class clazz = t.findClass("PMD");
46          assertEquals(PMD.class, clazz);
47      }
48  
49      @Test
50      public void testFindClassExplicitImport() throws Throwable {
51          TypeSet t = new TypeSet();
52          t.addImport("java.io.File");
53          Class clazz = t.findClass("File");
54          assertEquals(File.class, clazz);
55      }
56  
57      @Test
58      public void testFindClassImportOnDemand() throws Throwable {
59          TypeSet t = new TypeSet();
60          t.addImport("java.io.*");
61          Class clazz = t.findClass("File");
62          assertEquals(File.class, clazz);
63      }
64  
65      @Test
66      public void testFindClassPrimitive() throws Throwable {
67          TypeSet t = new TypeSet();
68          assertEquals(int.class, t.findClass("int"));
69      }
70  
71      @Test
72      public void testFindClassVoid() throws Throwable {
73          TypeSet t = new TypeSet();
74          assertEquals(void.class, t.findClass("void"));
75      }
76  
77      @Test
78      public void testFindFullyQualified() throws Throwable {
79          TypeSet t = new TypeSet();
80          assertEquals(String.class, t.findClass("java.lang.String"));
81          assertEquals(Set.class, t.findClass("java.util.Set"));
82      }
83  
84      // inner class tests
85      @Test
86      public void testPrimitiveTypeResolver() throws Throwable {
87          TypeSet.Resolver r = new TypeSet.PrimitiveTypeResolver();
88          assertEquals(int.class, r.resolve("int"));
89          assertEquals(byte.class, r.resolve("byte"));
90          assertEquals(long.class, r.resolve("long"));
91      }
92  
93      @Test(expected=ClassNotFoundException.class)
94      public void testPrimitiveTypeResolverWithNull() throws Throwable {
95          TypeSet.Resolver r = new TypeSet.PrimitiveTypeResolver();
96          r.resolve(null);
97      }
98  
99      @Test
100     public void testVoidTypeResolver() throws Throwable {
101         TypeSet.Resolver r = new TypeSet.VoidResolver();
102         assertEquals(void.class, r.resolve("void"));
103     }
104 
105     @Test(expected=ClassNotFoundException.class)
106     public void testVoidTypeResolverWithNull() throws Throwable {
107         TypeSet.Resolver r = new TypeSet.VoidResolver();
108         r.resolve(null);
109     }
110 
111     @Test
112     public void testExplicitImportResolver() throws Throwable {
113         Set<String> imports = new HashSet<String>();
114         imports.add("java.io.File");
115         TypeSet.Resolver r = new TypeSet.ExplicitImportResolver(pmdClassLoader, imports);
116         assertEquals(File.class, r.resolve("File"));
117     }
118 
119     @Test(expected=ClassNotFoundException.class)
120     public void testExplicitImportResolverWithNull() throws Throwable {
121         Set<String> imports = new HashSet<String>();
122         imports.add("java.io.File");
123         TypeSet.Resolver r = new TypeSet.ExplicitImportResolver(pmdClassLoader, imports);
124         r.resolve(null);
125     }
126 
127     @Test(expected=ClassNotFoundException.class)
128     public void testExplicitImportResolverWithNullAndEmptyImports() throws Throwable {
129         TypeSet.Resolver r = new TypeSet.ExplicitImportResolver(pmdClassLoader, new HashSet<String>());
130         r.resolve(null);
131     }
132 
133     @Test
134     public void testImplicitImportResolverPass() throws Throwable {
135         TypeSet.Resolver r = new TypeSet.ImplicitImportResolver(pmdClassLoader);
136         assertEquals(String.class, r.resolve("String"));
137     }
138 
139     @Test(expected=ClassNotFoundException.class)
140     public void testImplicitImportResolverPassFail() throws Throwable {
141         TypeSet.Resolver r = new TypeSet.ImplicitImportResolver(pmdClassLoader);
142         r.resolve("PMD");
143     }
144 
145     @Test(expected=ClassNotFoundException.class)
146     public void testImplicitImportResolverWithNull() throws Throwable {
147         TypeSet.Resolver r = new TypeSet.ImplicitImportResolver(pmdClassLoader);
148         r.resolve(null);
149     }
150 
151     @Test
152     public void testCurrentPackageResolverPass() throws Throwable {
153         TypeSet.Resolver r = new TypeSet.CurrentPackageResolver(pmdClassLoader, "net.sourceforge.pmd");
154         assertEquals(PMD.class, r.resolve("PMD"));
155     }
156 
157     @Test(expected=ClassNotFoundException.class)
158     public void testCurrentPackageResolverWithNull() throws Throwable {
159         TypeSet.Resolver r = new TypeSet.CurrentPackageResolver(pmdClassLoader, "net.sourceforge.pmd");
160         r.resolve(null);
161     }
162 
163     @Test
164     public void testImportOnDemandResolverPass() throws Throwable {
165         TypeSet.Resolver r = getResolver();
166         assertEquals(Set.class, r.resolve("Set"));
167         assertEquals(File.class, r.resolve("File"));
168     }
169 
170     @Test(expected = ClassNotFoundException.class)
171     public void testImportOnDemandResolverWithNull() throws Throwable {
172         TypeSet.Resolver r = getResolver();
173         r.resolve(null);
174     }
175 
176     @Test(expected = ClassNotFoundException.class)
177     public void importOnDemandResolverFail1() throws Throwable {
178         TypeSet.Resolver r = getResolver();
179         r.resolve("foo");
180     }
181 
182     @Test(expected = ClassNotFoundException.class)
183     public void importOnDemandResolverFail2() throws Throwable {
184         TypeSet.Resolver r = getResolver();
185         r.resolve("String");
186     }
187 
188     private TypeSet.Resolver getResolver() {
189         Set<String> imports = new HashSet<String>();
190         imports.add("java.io.*");
191         imports.add("java.util.*");
192         TypeSet.Resolver r = new TypeSet.ImportOnDemandResolver(pmdClassLoader, imports);
193         return r;
194     }
195 
196     @Test(expected = ClassNotFoundException.class)
197     public void testFullyQualifiedNameResolverWithNull() throws Throwable {
198         TypeSet.Resolver r = new TypeSet.FullyQualifiedNameResolver(pmdClassLoader);
199         r.resolve(null);
200     }
201 
202     public static junit.framework.Test suite() {
203         return new junit.framework.JUnit4TestAdapter(TypeSetTest.class);
204     }
205 }