001    package serp.bytecode;
002    
003    import java.io.*;
004    
005    import junit.framework.*;
006    import junit.textui.*;
007    
008    /**
009     * Tests the {@link BCClass} type.
010     *
011     * @author Abe White
012     */
013    public class TestBCClass extends TestCase {
014        private Project _project = new Project();
015        private BCClass _bc = _project.loadClass(Integer.class);
016    
017        public TestBCClass(String test) {
018            super(test);
019        }
020    
021        /**
022         * Test accessing the class project.
023         */
024        public void testProject() {
025            assertTrue(_project == _bc.getProject());
026            assertTrue(_bc.isValid());
027            assertTrue(_project.removeClass(_bc));
028            assertTrue(!_bc.isValid());
029        }
030    
031        /**
032         * Test read/write.
033         */
034        public void testReadWrite() throws IOException {
035            ByteArrayOutputStream out = new ByteArrayOutputStream();
036            InputStream in = Integer.class.getResourceAsStream("Integer.class");
037            int ch;
038    
039            while ((ch = in.read()) != -1)
040                out.write(ch);
041    
042            byte[] origBytes = out.toByteArray();
043            byte[] bytes = _bc.toByteArray();
044            assertEquals(origBytes.length, bytes.length);
045    
046            for (int i = 0; i < origBytes.length; i++)
047                assertEquals(origBytes[i], bytes[i]);
048    
049            // also test copying one class to another
050            BCClass bc2 = new Project().loadClass(_bc);
051            bytes = bc2.toByteArray();
052            assertEquals(origBytes.length, bytes.length);
053    
054            for (int i = 0; i < origBytes.length; i++)
055                assertEquals(origBytes[i], bytes[i]);
056        }
057    
058        /**
059         * Test basics -- magic number, major version, minor version.
060         */
061        public void testBasics() {
062            assertEquals(Constants.VALID_MAGIC, _bc.getMagic());
063            _bc.setMagic(1);
064            assertEquals(1, _bc.getMagic());
065    
066            assertTrue(Constants.MAJOR_VERSION <= _bc.getMajorVersion());
067            _bc.setMajorVersion(1);
068            assertEquals(1, _bc.getMajorVersion());
069    
070            _bc.setMinorVersion(1);
071            assertEquals(1, _bc.getMinorVersion());
072    
073            assertTrue(!_bc.isPrimitive());
074            assertTrue(!_bc.isArray());
075            assertNull(_bc.getComponentName());
076            assertNull(_bc.getComponentType());
077            assertNull(_bc.getComponentBC());
078        }
079    
080        /**
081         * Test access flags.
082         */
083        public void testAccessFlags() {
084            assertEquals(Constants.ACCESS_PUBLIC | Constants.ACCESS_SUPER |
085                Constants.ACCESS_FINAL, _bc.getAccessFlags());
086            assertTrue(_bc.isPublic());
087            assertTrue(!_bc.isPackage());
088            assertTrue(_bc.isFinal());
089            assertTrue(!_bc.isInterface());
090            assertTrue(!_bc.isAbstract());
091    
092            _bc.setAccessFlags(Constants.ACCESS_ABSTRACT |
093                Constants.ACCESS_INTERFACE);
094            assertTrue(!_bc.isPublic());
095            assertTrue(_bc.isPackage());
096            assertTrue(!_bc.isFinal());
097            assertTrue(_bc.isInterface());
098            assertTrue(_bc.isAbstract());
099    
100            _bc.setAccessFlags(Constants.ACCESS_PUBLIC | Constants.ACCESS_SUPER |
101                Constants.ACCESS_FINAL);
102    
103            _bc.makePackage();
104            assertTrue(!_bc.isPublic());
105            assertTrue(_bc.isPackage());
106            _bc.makePublic();
107            assertTrue(_bc.isPublic());
108            assertTrue(!_bc.isPackage());
109    
110            _bc.setFinal(false);
111            assertTrue(!_bc.isFinal());
112            _bc.setFinal(true);
113            assertTrue(_bc.isFinal());
114    
115            _bc.setAbstract(true);
116            assertTrue(_bc.isAbstract());
117            _bc.setAbstract(false);
118            assertTrue(!_bc.isAbstract());
119    
120            _bc.setInterface(true);
121            assertTrue(_bc.isInterface());
122            assertTrue(_bc.isAbstract());
123            _bc.setInterface(false);
124            assertTrue(!_bc.isInterface());
125        }
126    
127        /**
128         * Test class type operations.
129         */
130        public void testType() {
131            assertEquals(Integer.class.getName(), _bc.getName());
132            assertEquals("java.lang", _bc.getPackageName());
133            assertEquals("Integer", _bc.getClassName());
134            assertEquals(Integer.class, _bc.getType());
135    
136            _bc.setName("serp.Foo");
137            assertEquals("serp.Foo", _bc.getName());
138        }
139    
140        /**
141         * Test superclass operations.
142         */
143        public void testSuperclass() {
144            assertEquals(Number.class.getName(), _bc.getSuperclassName());
145            assertEquals(Number.class, _bc.getSuperclassType());
146            assertEquals(Number.class.getName(), _bc.getSuperclassBC().getName());
147            assertEquals(null,
148                _bc.getSuperclassBC().getSuperclassBC().getSuperclassBC());
149    
150            _bc.setSuperclass(String.class);
151            assertEquals(String.class.getName(), _bc.getSuperclassName());
152    
153            _bc.setSuperclass((BCClass) null);
154            _bc.setSuperclass((Class) null);
155            _bc.setSuperclass((String) null);
156            assertNull(_bc.getSuperclassName());
157            assertNull(_bc.getSuperclassType());
158            assertNull(_bc.getSuperclassBC());
159    
160            assertEquals(0, _bc.getSuperclassIndex());
161        }
162    
163        /**
164         * Test operations on interfaces.
165         */
166        public void testInterfaces() {
167            Object[] interfaces = _bc.getInterfaceNames();
168            assertEquals(2, interfaces.length);
169            assertEquals(Comparable.class.getName(), interfaces[0]);
170            assertEquals(Serializable.class.getName(), interfaces[1]);
171    
172            interfaces = _bc.getInterfaceTypes();
173            assertEquals(2, interfaces.length);
174            assertEquals(Comparable.class, interfaces[0]);
175            assertEquals(Serializable.class, interfaces[1]);
176    
177            interfaces = _bc.getInterfaceBCs();
178            assertEquals(2, interfaces.length);
179            assertEquals(Comparable.class, ((BCClass) interfaces[0]).getType());
180            assertEquals(Serializable.class, ((BCClass) interfaces[1]).getType());
181    
182            interfaces = _bc.getDeclaredInterfaceNames();
183            assertEquals(1, interfaces.length);
184            assertEquals(Comparable.class.getName(), interfaces[0]);
185    
186            interfaces = _bc.getDeclaredInterfaceTypes();
187            assertEquals(1, interfaces.length);
188            assertEquals(Comparable.class, interfaces[0]);
189    
190            interfaces = _bc.getDeclaredInterfaceBCs();
191            assertEquals(1, interfaces.length);
192            assertEquals(Comparable.class, ((BCClass) interfaces[0]).getType());
193    
194            assertTrue(_bc.isInstanceOf(Comparable.class.getName()));
195            assertTrue(_bc.isInstanceOf(Comparable.class));
196            assertTrue(_bc.isInstanceOf(_project.loadClass(Comparable.class)));
197            assertTrue(_bc.isInstanceOf(Serializable.class));
198            assertTrue(!_bc.isInstanceOf(Cloneable.class.getName()));
199            assertTrue(!_bc.isInstanceOf(Cloneable.class));
200            assertTrue(!_bc.isInstanceOf(_project.loadClass(Cloneable.class)));
201    
202            _bc.clearDeclaredInterfaces();
203            interfaces = _bc.getInterfaceNames();
204            assertEquals(1, interfaces.length);
205            assertEquals(Serializable.class.getName(), interfaces[0]);
206    
207            interfaces = _bc.getDeclaredInterfaceNames();
208            assertEquals(0, interfaces.length);
209    
210            _bc.declareInterface(Comparable.class.getName());
211            assertTrue(_bc.isInstanceOf(Comparable.class.getName()));
212            interfaces = _bc.getDeclaredInterfaceNames();
213            assertEquals(1, interfaces.length);
214            assertEquals(Comparable.class.getName(), interfaces[0]);
215    
216            assertTrue(!_bc.removeDeclaredInterface(Serializable.class));
217            assertTrue(_bc.removeDeclaredInterface(Comparable.class.getName()));
218            interfaces = _bc.getDeclaredInterfaceNames();
219            assertEquals(0, interfaces.length);
220    
221            _bc.declareInterface(Comparable.class);
222            assertTrue(_bc.isInstanceOf(Comparable.class));
223            interfaces = _bc.getDeclaredInterfaceTypes();
224            assertEquals(1, interfaces.length);
225            assertEquals(Comparable.class, interfaces[0]);
226    
227            assertTrue(_bc.removeDeclaredInterface(Comparable.class));
228            interfaces = _bc.getDeclaredInterfaceNames();
229            assertEquals(0, interfaces.length);
230    
231            _bc.declareInterface(_project.loadClass(Comparable.class));
232            assertTrue(_bc.isInstanceOf(_project.loadClass(Comparable.class)));
233            interfaces = _bc.getDeclaredInterfaceBCs();
234            assertEquals(1, interfaces.length);
235            assertEquals(Comparable.class, ((BCClass) interfaces[0]).getType());
236    
237            assertTrue(_bc.removeDeclaredInterface(_project.loadClass(
238                        Comparable.class)));
239            interfaces = _bc.getDeclaredInterfaceNames();
240            assertEquals(0, interfaces.length);
241        }
242    
243        public static Test suite() {
244            return new TestSuite(TestBCClass.class);
245        }
246    
247        public static void main(String[] args) {
248            TestRunner.run(suite());
249        }
250    }