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 }