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 BCClass} type.
10   *
11   * @author Abe White
12   */
13  public class TestBCClass extends TestCase {
14      private Project _project = new Project();
15      private BCClass _bc = _project.loadClass(Integer.class);
16  
17      public TestBCClass(String test) {
18          super(test);
19      }
20  
21      /**
22       * Test accessing the class project.
23       */
24      public void testProject() {
25          assertTrue(_project == _bc.getProject());
26          assertTrue(_bc.isValid());
27          assertTrue(_project.removeClass(_bc));
28          assertTrue(!_bc.isValid());
29      }
30  
31      /**
32       * Test read/write.
33       */
34      public void testReadWrite() throws IOException {
35          ByteArrayOutputStream out = new ByteArrayOutputStream();
36          InputStream in = Integer.class.getResourceAsStream("Integer.class");
37          int ch;
38  
39          while ((ch = in.read()) != -1)
40              out.write(ch);
41  
42          byte[] origBytes = out.toByteArray();
43          byte[] bytes = _bc.toByteArray();
44          assertEquals(origBytes.length, bytes.length);
45  
46          for (int i = 0; i < origBytes.length; i++)
47              assertEquals(origBytes[i], bytes[i]);
48  
49          // also test copying one class to another
50          BCClass bc2 = new Project().loadClass(_bc);
51          bytes = bc2.toByteArray();
52          assertEquals(origBytes.length, bytes.length);
53  
54          for (int i = 0; i < origBytes.length; i++)
55              assertEquals(origBytes[i], bytes[i]);
56      }
57  
58      /**
59       * Test basics -- magic number, major version, minor version.
60       */
61      public void testBasics() {
62          assertEquals(Constants.VALID_MAGIC, _bc.getMagic());
63          _bc.setMagic(1);
64          assertEquals(1, _bc.getMagic());
65  
66          assertTrue(Constants.MAJOR_VERSION <= _bc.getMajorVersion());
67          _bc.setMajorVersion(1);
68          assertEquals(1, _bc.getMajorVersion());
69  
70          _bc.setMinorVersion(1);
71          assertEquals(1, _bc.getMinorVersion());
72  
73          assertTrue(!_bc.isPrimitive());
74          assertTrue(!_bc.isArray());
75          assertNull(_bc.getComponentName());
76          assertNull(_bc.getComponentType());
77          assertNull(_bc.getComponentBC());
78      }
79  
80      /**
81       * Test access flags.
82       */
83      public void testAccessFlags() {
84          assertEquals(Constants.ACCESS_PUBLIC | Constants.ACCESS_SUPER |
85              Constants.ACCESS_FINAL, _bc.getAccessFlags());
86          assertTrue(_bc.isPublic());
87          assertTrue(!_bc.isPackage());
88          assertTrue(_bc.isFinal());
89          assertTrue(!_bc.isInterface());
90          assertTrue(!_bc.isAbstract());
91  
92          _bc.setAccessFlags(Constants.ACCESS_ABSTRACT |
93              Constants.ACCESS_INTERFACE);
94          assertTrue(!_bc.isPublic());
95          assertTrue(_bc.isPackage());
96          assertTrue(!_bc.isFinal());
97          assertTrue(_bc.isInterface());
98          assertTrue(_bc.isAbstract());
99  
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 }