001    package serp.bytecode;
002    
003    import java.io.*;
004    
005    import junit.framework.*;
006    import junit.textui.*;
007    
008    /**
009     * Tests the {@link Project} type.
010     *
011     * @author Abe White
012     */
013    public class TestProject extends TestCase {
014        private Project _project = new Project();
015    
016        public TestProject(String test) {
017            super(test);
018        }
019    
020        /**
021         * Test the project name.
022         */
023        public void testName() {
024            assertNull(_project.getName());
025            assertNull(new Project(null).getName());
026            assertEquals("foo", new Project("foo").getName());
027        }
028    
029        /**
030         * Test loading classes by name.
031         */
032        public void testLoadByName() {
033            BCClass bc;
034            BCClass bc2;
035            String[] names;
036            String[] names2;
037    
038            // test primitive types
039            names = new String[] {
040                "boolean", "byte", "char", "double", "float", "int", "long",
041                "short", "void"
042            };
043            names2 = new String[] { "Z", "B", "C", "D", "F", "I", "J", "S", "V" };
044            for (int i = 0; i < names.length; i++) {
045                bc = _project.loadClass(names[i]);
046                bc2 = _project.loadClass(names2[i]);
047                assertTrue(names[i], bc == bc2);
048                assertTrue(names[i], bc.isPrimitive());
049                assertEquals(names[i], bc.getName());
050            }
051    
052            // test primitive array types
053            names = new String[] {
054                "boolean[]", "byte[]", "char[]", "double[]", "float[]", "int[]",
055                "long[]", "short[]"
056            };
057            names2 = new String[] {"[Z", "[B", "[C", "[D", "[F", "[I", "[J", "[S" };
058            for (int i = 0; i < names.length; i++) {
059                bc = _project.loadClass(names[i]);
060                bc2 = _project.loadClass(names2[i]);
061                assertTrue(names[i], bc == bc2);
062                assertTrue(names[i], bc.isArray());
063                assertEquals(names2[i], bc.getName());
064            }
065    
066            // test new object type
067            bc = _project.loadClass("serp.Foo");
068            bc2 = _project.loadClass("serp.Foo");
069            assertTrue(bc == bc2);
070            assertTrue(!bc.isPrimitive());
071            assertTrue(!bc.isArray());
072            assertEquals("serp.Foo", bc.getName());
073    
074            // test new object array type
075            bc = _project.loadClass("serp.Foo[]");
076            bc2 = _project.loadClass("[Lserp.Foo;");
077            assertTrue(bc == bc2);
078            assertTrue(bc.isArray());
079            assertEquals("[Lserp.Foo;", bc.getName());
080    
081            // test existing object type
082            bc = _project.loadClass(String.class.getName());
083            bc2 = _project.loadClass(String.class);
084            assertTrue(bc == bc2);
085            assertTrue(!bc.isPrimitive());
086            assertTrue(!bc.isArray());
087            assertEquals(String.class.getName(), bc.getName());
088            assertEquals("length", bc.getDeclaredMethod("length").getName());
089    
090            // test new object array type
091            bc = _project.loadClass(String.class.getName() + "[]");
092            bc2 = _project.loadClass(String[].class);
093            assertTrue(bc == bc2);
094            assertTrue(bc.isArray());
095            assertEquals(String[].class.getName(), bc.getName());
096        }
097    
098        /**
099         * 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    }