View Javadoc

1   package serp.bytecode;
2   
3   import java.io.*;
4   
5   import junit.framework.*;
6   import junit.textui.*;
7   
8   /**
9    * Tests the {@link Project} type.
10   *
11   * @author Abe White
12   */
13  public class TestProject extends TestCase {
14      private Project _project = new Project();
15  
16      public TestProject(String test) {
17          super(test);
18      }
19  
20      /**
21       * Test the project name.
22       */
23      public void testName() {
24          assertNull(_project.getName());
25          assertNull(new Project(null).getName());
26          assertEquals("foo", new Project("foo").getName());
27      }
28  
29      /**
30       * Test loading classes by name.
31       */
32      public void testLoadByName() {
33          BCClass bc;
34          BCClass bc2;
35          String[] names;
36          String[] names2;
37  
38          // test primitive types
39          names = new String[] {
40              "boolean", "byte", "char", "double", "float", "int", "long",
41              "short", "void"
42          };
43          names2 = new String[] { "Z", "B", "C", "D", "F", "I", "J", "S", "V" };
44          for (int i = 0; i < names.length; i++) {
45              bc = _project.loadClass(names[i]);
46              bc2 = _project.loadClass(names2[i]);
47              assertTrue(names[i], bc == bc2);
48              assertTrue(names[i], bc.isPrimitive());
49              assertEquals(names[i], bc.getName());
50          }
51  
52          // test primitive array types
53          names = new String[] {
54              "boolean[]", "byte[]", "char[]", "double[]", "float[]", "int[]",
55              "long[]", "short[]"
56          };
57          names2 = new String[] {"[Z", "[B", "[C", "[D", "[F", "[I", "[J", "[S" };
58          for (int i = 0; i < names.length; i++) {
59              bc = _project.loadClass(names[i]);
60              bc2 = _project.loadClass(names2[i]);
61              assertTrue(names[i], bc == bc2);
62              assertTrue(names[i], bc.isArray());
63              assertEquals(names2[i], bc.getName());
64          }
65  
66          // test new object type
67          bc = _project.loadClass("serp.Foo");
68          bc2 = _project.loadClass("serp.Foo");
69          assertTrue(bc == bc2);
70          assertTrue(!bc.isPrimitive());
71          assertTrue(!bc.isArray());
72          assertEquals("serp.Foo", bc.getName());
73  
74          // test new object array type
75          bc = _project.loadClass("serp.Foo[]");
76          bc2 = _project.loadClass("[Lserp.Foo;");
77          assertTrue(bc == bc2);
78          assertTrue(bc.isArray());
79          assertEquals("[Lserp.Foo;", bc.getName());
80  
81          // test existing object type
82          bc = _project.loadClass(String.class.getName());
83          bc2 = _project.loadClass(String.class);
84          assertTrue(bc == bc2);
85          assertTrue(!bc.isPrimitive());
86          assertTrue(!bc.isArray());
87          assertEquals(String.class.getName(), bc.getName());
88          assertEquals("length", bc.getDeclaredMethod("length").getName());
89  
90          // test new object array type
91          bc = _project.loadClass(String.class.getName() + "[]");
92          bc2 = _project.loadClass(String[].class);
93          assertTrue(bc == bc2);
94          assertTrue(bc.isArray());
95          assertEquals(String[].class.getName(), bc.getName());
96      }
97  
98      /**
99       * Test loading classes by type.
100      */
101     public void testLoadByType() {
102         BCClass bc;
103         BCClass bc2;
104         Class[] types;
105         String[] names;
106 
107         // test primitive types
108         types = new Class[] {
109             boolean.class, byte.class, char.class, double.class, float.class,
110             int.class, long.class, short.class, void.class
111         };
112         names = new String[] { "Z", "B", "C", "D", "F", "I", "J", "S", "V" };
113         for (int i = 0; i < names.length; i++) {
114             bc = _project.loadClass(types[i]);
115             bc2 = _project.loadClass(names[i]);
116             assertTrue(types[i].getName(), bc == bc2);
117             assertTrue(types[i].getName(), bc.isPrimitive());
118             assertEquals(types[i].getName(), bc.getName());
119         }
120 
121         // test primitive array types
122         types = new Class[] {
123             boolean[].class, byte[].class, char[].class, double[].class,
124             float[].class, int[].class, long[].class, short[].class,
125         };
126         names = new String[] { "[Z", "[B", "[C", "[D", "[F", "[I", "[J", "[S" };
127 
128         for (int i = 0; i < names.length; i++) {
129             bc = _project.loadClass(types[i]);
130             bc2 = _project.loadClass(names[i]);
131             assertTrue(types[i].getName(), bc == bc2);
132             assertTrue(types[i].getName(), bc.isArray());
133             assertEquals(types[i].getName(), bc.getName());
134         }
135 
136         // test existing object type
137         bc = _project.loadClass(String.class);
138         bc2 = _project.loadClass(String.class.getName());
139         assertTrue(bc == bc2);
140         assertTrue(!bc.isPrimitive());
141         assertTrue(!bc.isArray());
142         assertEquals(String.class.getName(), bc.getName());
143         assertEquals("length", bc.getDeclaredMethod("length").getName());
144 
145         // test new object array type
146         bc = _project.loadClass(String[].class);
147         bc2 = _project.loadClass(String.class.getName() + "[]");
148         assertTrue(bc == bc2);
149         assertTrue(bc.isArray());
150         assertEquals(String[].class.getName(), bc.getName());
151     }
152 
153     /**
154      * Test loading classes by file.
155      */
156     public void testLoadByFile() {
157         File file = new File(getClass().getResource("TestProject.class").
158             getFile());
159 
160         BCClass bc = _project.loadClass(file);
161         BCClass bc2 = _project.loadClass(file);
162         assertTrue(bc == bc2);
163         assertTrue(!bc.isPrimitive());
164         assertTrue(!bc.isArray());
165         assertEquals(getClass().getName(), bc.getName());
166         assertEquals("main", bc.getDeclaredMethod("main").getName());
167     }
168 
169     /**
170      * Test loading classes by stream.
171      */
172     public void testLoadByStream() {
173         InputStream in = getClass().getResourceAsStream("TestProject.class");
174         InputStream in2 = getClass().getResourceAsStream("TestProject.class");
175 
176         BCClass bc = _project.loadClass(in);
177         BCClass bc2 = _project.loadClass(in2);
178         assertTrue(bc == bc2);
179         assertTrue(!bc.isPrimitive());
180         assertTrue(!bc.isArray());
181         assertEquals(getClass().getName(), bc.getName());
182         assertEquals("main", bc.getDeclaredMethod("main").getName());
183     }
184 
185     /**
186      * Test retrieving all loaded classes.
187      */
188     public void testGetClasses() {
189         BCClass[] bcs = _project.getClasses();
190         assertEquals(0, bcs.length);
191 
192         BCClass[] added = new BCClass[3];
193         added[0] = _project.loadClass("int");
194         added[1] = _project.loadClass("serp.Foo");
195         added[2] = _project.loadClass(String[].class);
196 
197         bcs = _project.getClasses();
198         assertEquals(3, bcs.length);
199         int matches;
200         for (int i = 0; i < added.length; i++) {
201             matches = 0;
202             for (int j = 0; j < bcs.length; j++)
203                 if (added[i] == bcs[j])
204                     matches++;
205             assertEquals(1, matches);
206         }
207     }
208 
209     /**
210      * Test renaming classes within the project.
211      */
212     public void testRename() {
213         BCClass str = _project.loadClass(String.class);
214         BCClass foo = _project.loadClass("serp.Foo");
215 
216         str.setName("java.lang.String2");
217         assertEquals("java.lang.String2", str.getName());
218         foo.setName("serp.Foo2");
219         assertEquals("serp.Foo2", foo.getName());
220         try {
221             str.setName("serp.Foo2");
222             fail("Set to existing name");
223         } catch (IllegalStateException ise) {
224         }
225 
226         assertEquals("java.lang.String2", str.getName());
227         try {
228             foo.setName("java.lang.String2");
229             fail("Set to existing name");
230         } catch (IllegalStateException ise) {
231         }
232 
233         assertEquals("serp.Foo2", foo.getName());
234 
235         str.setName("serp.Foo");
236         assertEquals("serp.Foo", str.getName());
237 
238         foo.setName("java.lang.String");
239         assertEquals("java.lang.String", foo.getName());
240 
241         assertTrue(foo == _project.loadClass(String.class));
242         assertTrue(str == _project.loadClass("serp.Foo"));
243     }
244 
245     /**
246      * Test clearing classes.
247      */
248     public void testClear() {
249         _project.clear();
250 
251         BCClass bc1 = _project.loadClass("int");
252         BCClass bc2 = _project.loadClass("serp.Foo");
253         BCClass bc3 = _project.loadClass(String[].class);
254 
255         assertTrue(bc1.isValid());
256         assertTrue(bc2.isValid());
257         assertTrue(bc3.isValid());
258 
259         assertEquals(3, _project.getClasses().length);
260         _project.clear();
261         assertEquals(0, _project.getClasses().length);
262 
263         // cleared classes should be invalid
264         assertTrue(!bc1.isValid());
265         assertTrue(!bc2.isValid());
266         assertTrue(!bc3.isValid());
267     }
268 
269     /**
270      * Test removing a class.
271      */
272     public void testRemove() {
273         assertTrue(!_project.removeClass((String) null));
274         assertTrue(!_project.removeClass((Class) null));
275         assertTrue(!_project.removeClass((BCClass) null));
276 
277         BCClass bc1 = _project.loadClass("int");
278         BCClass bc2 = _project.loadClass("serp.Foo");
279         BCClass bc3 = _project.loadClass(String[].class);
280 
281         assertTrue(bc1.isValid());
282         assertTrue(bc2.isValid());
283         assertTrue(bc3.isValid());
284 
285         assertTrue(!_project.removeClass(new Project().loadClass("int")));
286         assertTrue(_project.removeClass(bc1));
287         assertTrue(!bc1.isValid());
288         assertEquals(2, _project.getClasses().length);
289 
290         assertTrue(_project.removeClass("serp.Foo"));
291         assertTrue(!bc1.isValid());
292         assertEquals(1, _project.getClasses().length);
293 
294         assertTrue(_project.removeClass(String[].class));
295         assertTrue(!bc1.isValid());
296         assertEquals(0, _project.getClasses().length);
297     }
298 
299     public static Test suite() {
300         return new TestSuite(TestProject.class);
301     }
302 
303     public static void main(String[] args) {
304         TestRunner.run(suite());
305     }
306 }